added test and lag

kaggle_evaluation/__init__.py

@@ -0,0 +1,22 @@
+'''
+Module implementing generic communication patterns with Python in / Python out
+supporting many (nested) primitives + special data science types like DataFrames
+or np.ndarrays, with gRPC + protobuf as a backing implementation.
+'''
+
+import os
+import sys
+
+# Provide additional import management since grpc_tools.protoc doesn't support relative imports
+module_dir = os.path.dirname(os.path.abspath(__file__))
+gen_dir = os.path.join(module_dir, 'core', 'generated')
+
+if not os.path.exists(os.path.join(gen_dir, 'kaggle_evaluation_pb2.py')):
+    print('kaggle evaluation proto and gRPC generated files are missing')
+    sys.exit(1)
+
+sys.path.append(module_dir)
+sys.path.append(gen_dir)
+
+
+__version__ = '0.3.0'

kaggle_evaluation/core/__init__.py

@@ -0,0 +1,5 @@
+import os
+import sys
+
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))

kaggle_evaluation/core/base_gateway.py

@@ -0,0 +1,195 @@
+''' Lower level implementation details of the gateway.
+Hosts should not need to review this file before writing their competition specific gateway.
+'''
+
+import enum
+import json
+import os
+import pathlib
+import re
+import subprocess
+
+from socket import gaierror
+from typing import List, Optional, Tuple, Union
+
+import grpc
+import pandas as pd
+import polars as pl
+
+import kaggle_evaluation.core.relay
+
+
+_FILE_SHARE_DIR = '/kaggle/shared/'
+IS_RERUN = os.getenv('KAGGLE_IS_COMPETITION_RERUN') is not None
+
+
+class GatewayRuntimeErrorType(enum.Enum):
+    ''' Allow-listed error types that Gateways can raise, which map to canned error messages to show users.'''
+    UNSPECIFIED = 0
+    SERVER_NEVER_STARTED = 1
+    SERVER_CONNECTION_FAILED = 2
+    SERVER_RAISED_EXCEPTION = 3
+    SERVER_MISSING_ENDPOINT = 4
+    # Default error type if an exception was raised that was not explicitly handled by the Gateway
+    GATEWAY_RAISED_EXCEPTION = 5
+    INVALID_SUBMISSION = 6
+
+
+class GatewayRuntimeError(Exception):
+    ''' Gateways can raise this error to capture a user-visible error enum from above and host-visible error details.'''
+    def __init__(self, error_type: GatewayRuntimeErrorType, error_details: Optional[str]=None):
+        self.error_type = error_type
+        self.error_details = error_details
+
+
+class BaseGateway():
+    def __init__(self, data_paths: Tuple[str]=None, file_share_dir: str=_FILE_SHARE_DIR):
+        self.client = kaggle_evaluation.core.relay.Client('inference_server' if IS_RERUN else 'localhost')
+        self.server = None  # The gateway can have a server but it isn't typically necessary.
+        self.file_share_dir = file_share_dir
+        self.data_paths = data_paths
+
+    def validate_prediction_batch(
+        self,
+        prediction_batch: Union[pd.DataFrame, pl.DataFrame],
+        sample_submission_batch: Union[pd.DataFrame, pl.DataFrame]):
+        ''' If competitors can submit fewer rows than expected they can save all predictions for the last batch and
+        bypass the benefits of the Kaggle evaluation service. This attack was seen in a real competition with the older time series API:
+        https://www.kaggle.com/competitions/riiid-test-answer-prediction/discussion/196066
+        It's critically important that this check be run every time predict() is called.
+        '''
+        if prediction_batch is None:
+            raise GatewayRuntimeError(GatewayRuntimeErrorType.INVALID_SUBMISSION, 'No prediction received')
+        if len(prediction_batch) != len(sample_submission_batch):
+            raise GatewayRuntimeError(
+                GatewayRuntimeErrorType.INVALID_SUBMISSION,
+                f'Invalid predictions: expected {len(sample_submission_batch)} rows but received {len(prediction_batch)}'
+            )
+
+        ROW_ID_COLUMN_INDEX = 0
+        row_id_colname = sample_submission_batch.columns[ROW_ID_COLUMN_INDEX]
+        # Prevent frame shift attacks that could be performed if the IDs are predictable.
+        # Ensure both dataframes are in Polars for efficient comparison.
+        if row_id_colname not in prediction_batch.columns:
+            raise GatewayRuntimeError(GatewayRuntimeErrorType.INVALID_SUBMISSION, f'Prediction missing column {row_id_colname}')
+        if not pl.Series(prediction_batch[row_id_colname]).equals(pl.Series(sample_submission_batch[row_id_colname])):
+            raise GatewayRuntimeError(
+                GatewayRuntimeErrorType.INVALID_SUBMISSION,
+                f'Invalid values for {row_id_colname} in batch of predictions.'
+            )
+
+    def _standardize_and_validate_paths(
+            self,
+            input_paths: List[Union[str, pathlib.Path]]
+        ) -> List[pathlib.Path]:
+        # Accept a list of str or pathlib.Path, but standardize on list of str
+        for path in input_paths:
+            if os.pardir in str(path):
+                raise ValueError(f'Send files path contains {os.pardir}: {path}')
+            if str(path) != str(os.path.normpath(path)):
+                # Raise an error rather than sending users unexpectedly altered paths
+                raise ValueError(f'Send files path {path} must be normalized. See `os.path.normpath`')
+            if type(path) not in (pathlib.Path, str):
+                raise ValueError('All paths must be of type str or pathlib.Path')
+            if not os.path.exists(path):
+                raise ValueError(f'Input path {path} does not exist')
+
+        input_paths = [os.path.abspath(path) for path in input_paths]
+        if len(set(input_paths)) != len(input_paths):
+            raise ValueError('Duplicate input paths found')
+
+        if not self.file_share_dir.endswith(os.path.sep):
+            # Ensure output dir is valid for later use
+            output_dir = self.file_share_dir + os.path.sep
+
+        if not os.path.exists(self.file_share_dir) or not os.path.isdir(self.file_share_dir):
+            raise ValueError(f'Invalid output directory {self.file_share_dir}')
+        # Can't use os.path.join for output_dir + path: os.path.join won't prepend to an abspath
+        output_paths = [output_dir + path for path in input_paths]
+        return input_paths, output_paths
+
+    def share_files(
+            self,
+            input_paths: List[Union[str, pathlib.Path]],
+        ) -> List[str]:
+        ''' Makes files and/or directories available to the user's inference_server. They will be mirrored under the
+        self.file_share_dir directory, using the full absolute path. An input like:
+            /kaggle/input/mycomp/test.csv
+        Would be written to:
+            /kaggle/shared/kaggle/input/mycomp/test.csv
+
+        Args:
+            input_paths: List of paths to files and/or directories that should be shared.
+
+        Returns:
+            The output paths that were shared.
+
+        Raises:
+            ValueError if any invalid paths are passed.
+        '''
+        input_paths, output_paths = self._standardize_and_validate_paths(input_paths)
+        for in_path, out_path in zip(input_paths, output_paths):
+            os.makedirs(os.path.dirname(out_path), exist_ok=True)
+
+            # This makes the files available to the InferenceServer as read-only. Only the Gateway can mount files.
+            # mount will only work in live kaggle evaluation rerun sessions. Otherwise use a symlink.
+            if IS_RERUN:
+                if not os.path.isdir(out_path):
+                    pathlib.Path(out_path).touch()
+                subprocess.run(f'mount --bind {in_path} {out_path}', shell=True, check=True)
+            else:
+                subprocess.run(f'ln -s {in_path} {out_path}', shell=True, check=True)
+
+        return output_paths
+
+    def write_submission(self, predictions):
+        ''' Export the predictions to a submission.parquet.'''
+        if isinstance(predictions, list):
+            if isinstance(predictions[0], pd.DataFrame):
+                predictions = pd.concat(predictions, ignore_index=True)
+            elif isinstance(predictions[0], pl.DataFrame):
+                try:
+                    predictions = pl.concat(predictions, how='vertical_relaxed')
+                except pl.exceptions.SchemaError:
+                    raise GatewayRuntimeError(GatewayRuntimeErrorType.INVALID_SUBMISSION, 'Inconsistent prediction types')
+                except pl.exceptions.ComputeError:
+                    raise GatewayRuntimeError(GatewayRuntimeErrorType.INVALID_SUBMISSION, 'Inconsistent prediction column counts')
+
+        if isinstance(predictions, pd.DataFrame):
+            predictions.to_parquet('submission.parquet', index=False)
+        elif isinstance(predictions, pl.DataFrame):
+            pl.DataFrame(predictions).write_parquet('submission.parquet')
+        else:
+            raise ValueError(f"Unsupported predictions type {type(predictions)}; can't write submission file")
+
+    def write_result(self, error: Optional[GatewayRuntimeError]=None):
+        ''' Export a result.json containing error details if applicable.'''
+        result = { 'Succeeded': error is None }
+
+        if error is not None:
+            result['ErrorType'] = error.error_type.value
+            result['ErrorName'] = error.error_type.name
+            # Max error detail length is 8000
+            result['ErrorDetails'] = str(error.error_details[:8000]) if error.error_details else None
+
+        with open('result.json', 'w') as f_open:
+            json.dump(result, f_open)
+
+    def handle_server_error(self, exception: Exception, endpoint: str):
+        ''' Determine how to handle an exception raised when calling the inference server. Typically just format the
+        error into a GatewayRuntimeError and raise.
+        '''
+        exception_str = str(exception)
+        if isinstance(exception, gaierror) or (isinstance(exception, RuntimeError) and 'Failed to connect to server after waiting' in exception_str):
+            raise GatewayRuntimeError(GatewayRuntimeErrorType.SERVER_NEVER_STARTED) from None
+        if f'No listener for {endpoint} was registered' in exception_str:
+            raise GatewayRuntimeError(GatewayRuntimeErrorType.SERVER_MISSING_ENDPOINT, f'Server did not register a listener for {endpoint}') from None
+        if 'Exception calling application' in exception_str:
+            # Extract just the exception message raised by the inference server
+            message_match = re.search('"Exception calling application: (.*)"', exception_str, re.IGNORECASE)
+            message = message_match.group(1) if message_match else exception_str
+            raise GatewayRuntimeError(GatewayRuntimeErrorType.SERVER_RAISED_EXCEPTION, message) from None
+        if isinstance(exception, grpc._channel._InactiveRpcError):
+            raise GatewayRuntimeError(GatewayRuntimeErrorType.SERVER_CONNECTION_FAILED, exception_str) from None
+
+        raise exception

kaggle_evaluation/core/generated/__init__.py

@@ -0,0 +1,5 @@
+import os
+import sys
+
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))

kaggle_evaluation/core/generated/kaggle_evaluation_pb2.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: kaggle_evaluation.proto
+# Protobuf Python Version: 4.25.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x17kaggle_evaluation.proto\x12\x18kaggle_evaluation_client\"\xf9\x01\n\x17KaggleEvaluationRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\x12/\n\x04\x61rgs\x18\x02 \x03(\x0b\x32!.kaggle_evaluation_client.Payload\x12M\n\x06kwargs\x18\x03 \x03(\x0b\x32=.kaggle_evaluation_client.KaggleEvaluationRequest.KwargsEntry\x1aP\n\x0bKwargsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x30\n\x05value\x18\x02 \x01(\x0b\x32!.kaggle_evaluation_client.Payload:\x02\x38\x01\"N\n\x18KaggleEvaluationResponse\x12\x32\n\x07payload\x18\x01 \x01(\x0b\x32!.kaggle_evaluation_client.Payload\"\x8d\x04\n\x07Payload\x12\x13\n\tstr_value\x18\x01 \x01(\tH\x00\x12\x14\n\nbool_value\x18\x02 \x01(\x08H\x00\x12\x13\n\tint_value\x18\x03 \x01(\x12H\x00\x12\x15\n\x0b\x66loat_value\x18\x04 \x01(\x02H\x00\x12\x14\n\nnone_value\x18\x05 \x01(\x08H\x00\x12;\n\nlist_value\x18\x06 \x01(\x0b\x32%.kaggle_evaluation_client.PayloadListH\x00\x12<\n\x0btuple_value\x18\x07 \x01(\x0b\x32%.kaggle_evaluation_client.PayloadListH\x00\x12:\n\ndict_value\x18\x08 \x01(\x0b\x32$.kaggle_evaluation_client.PayloadMapH\x00\x12 \n\x16pandas_dataframe_value\x18\t \x01(\x0cH\x00\x12 \n\x16polars_dataframe_value\x18\n \x01(\x0cH\x00\x12\x1d\n\x13pandas_series_value\x18\x0b \x01(\x0cH\x00\x12\x1d\n\x13polars_series_value\x18\x0c \x01(\x0cH\x00\x12\x1b\n\x11numpy_array_value\x18\r \x01(\x0cH\x00\x12\x1c\n\x12numpy_scalar_value\x18\x0e \x01(\x0cH\x00\x12\x18\n\x0e\x62ytes_io_value\x18\x0f \x01(\x0cH\x00\x42\x07\n\x05value\"B\n\x0bPayloadList\x12\x33\n\x08payloads\x18\x01 \x03(\x0b\x32!.kaggle_evaluation_client.Payload\"\xad\x01\n\nPayloadMap\x12I\n\x0bpayload_map\x18\x01 \x03(\x0b\x32\x34.kaggle_evaluation_client.PayloadMap.PayloadMapEntry\x1aT\n\x0fPayloadMapEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x30\n\x05value\x18\x02 \x01(\x0b\x32!.kaggle_evaluation_client.Payload:\x02\x38\x01\x32\x8a\x01\n\x17KaggleEvaluationService\x12o\n\x04Send\x12\x31.kaggle_evaluation_client.KaggleEvaluationRequest\x1a\x32.kaggle_evaluation_client.KaggleEvaluationResponse\"\x00\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'kaggle_evaluation_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+  DESCRIPTOR._options = None
+  _globals['_KAGGLEEVALUATIONREQUEST_KWARGSENTRY']._options = None
+  _globals['_KAGGLEEVALUATIONREQUEST_KWARGSENTRY']._serialized_options = b'8\001'
+  _globals['_PAYLOADMAP_PAYLOADMAPENTRY']._options = None
+  _globals['_PAYLOADMAP_PAYLOADMAPENTRY']._serialized_options = b'8\001'
+  _globals['_KAGGLEEVALUATIONREQUEST']._serialized_start=54
+  _globals['_KAGGLEEVALUATIONREQUEST']._serialized_end=303
+  _globals['_KAGGLEEVALUATIONREQUEST_KWARGSENTRY']._serialized_start=223
+  _globals['_KAGGLEEVALUATIONREQUEST_KWARGSENTRY']._serialized_end=303
+  _globals['_KAGGLEEVALUATIONRESPONSE']._serialized_start=305
+  _globals['_KAGGLEEVALUATIONRESPONSE']._serialized_end=383
+  _globals['_PAYLOAD']._serialized_start=386
+  _globals['_PAYLOAD']._serialized_end=911
+  _globals['_PAYLOADLIST']._serialized_start=913
+  _globals['_PAYLOADLIST']._serialized_end=979
+  _globals['_PAYLOADMAP']._serialized_start=982
+  _globals['_PAYLOADMAP']._serialized_end=1155
+  _globals['_PAYLOADMAP_PAYLOADMAPENTRY']._serialized_start=1071
+  _globals['_PAYLOADMAP_PAYLOADMAPENTRY']._serialized_end=1155
+  _globals['_KAGGLEEVALUATIONSERVICE']._serialized_start=1158
+  _globals['_KAGGLEEVALUATIONSERVICE']._serialized_end=1296
+# @@protoc_insertion_point(module_scope)

kaggle_evaluation/core/generated/kaggle_evaluation_pb2_grpc.py

@@ -0,0 +1,66 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+
+import kaggle_evaluation_pb2 as kaggle__evaluation__pb2
+
+
+class KaggleEvaluationServiceStub(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.Send = channel.unary_unary(
+                '/kaggle_evaluation_client.KaggleEvaluationService/Send',
+                request_serializer=kaggle__evaluation__pb2.KaggleEvaluationRequest.SerializeToString,
+                response_deserializer=kaggle__evaluation__pb2.KaggleEvaluationResponse.FromString,
+                )
+
+
+class KaggleEvaluationServiceServicer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def Send(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_KaggleEvaluationServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'Send': grpc.unary_unary_rpc_method_handler(
+                    servicer.Send,
+                    request_deserializer=kaggle__evaluation__pb2.KaggleEvaluationRequest.FromString,
+                    response_serializer=kaggle__evaluation__pb2.KaggleEvaluationResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'kaggle_evaluation_client.KaggleEvaluationService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+
+
+ # This class is part of an EXPERIMENTAL API.
+class KaggleEvaluationService(object):
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def Send(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/kaggle_evaluation_client.KaggleEvaluationService/Send',
+            kaggle__evaluation__pb2.KaggleEvaluationRequest.SerializeToString,
+            kaggle__evaluation__pb2.KaggleEvaluationResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

kaggle_evaluation/core/kaggle_evaluation.proto

@@ -0,0 +1,66 @@
+// Defines the proto service for KaggleEvaluation communication, aiming to provide native
+// support for passing a variety of python primitives + common data science
+// objects, and nested objects thereof.
+
+syntax = "proto3";
+
+package kaggle_evaluation_client;
+
+service KaggleEvaluationService {
+  rpc Send(KaggleEvaluationRequest) returns (KaggleEvaluationResponse) {};
+}
+
+message KaggleEvaluationRequest {
+  string name = 1;
+  // Support generic python method calls using standard args / kwargs format.
+  repeated Payload args = 2;
+  map<string, Payload> kwargs = 3;
+}
+
+message KaggleEvaluationResponse {
+  Payload payload = 1;
+}
+
+// Core object representing a python value.
+message Payload {
+  oneof value {
+    // Primitives
+    string str_value = 1;
+    bool bool_value = 2;
+    sint64 int_value = 3;
+    float float_value = 4;
+    // Value is ignored, being set at all means `None`
+    bool none_value = 5;
+
+    // Iterables for nested types
+    PayloadList list_value = 6;
+    PayloadList tuple_value = 7;
+    // Only supports dict with keys of type str and values that are serializable
+    // to Payload as well.
+    PayloadMap dict_value = 8;
+
+    // Allowlisted special types
+    // pandas.DataFrame
+    bytes pandas_dataframe_value = 9;
+    // polars.DataFrame
+    bytes polars_dataframe_value = 10;
+    // pandas.Series
+    bytes pandas_series_value = 11;
+    // polars.Series
+    bytes polars_series_value = 12;
+    // numpy.ndarray
+    bytes numpy_array_value = 13;
+    // numpy.scalar. Distinct from numpy.ndarray to avoid issues with dimensionless numpy arrays
+    bytes numpy_scalar_value = 14;
+    // io.BytesIO
+    bytes bytes_io_value = 15;
+  }
+}
+
+message PayloadList {
+  repeated Payload payloads = 1;
+}
+
+message PayloadMap {
+  map<string, Payload> payload_map = 1;
+}

kaggle_evaluation/core/relay.py

@@ -0,0 +1,335 @@
+'''
+Core implementation of the client module, implementing generic communication
+patterns with Python in / Python out supporting many (nested) primitives +
+special data science types like DataFrames or np.ndarrays, with gRPC + protobuf
+as a backing implementation.
+'''
+
+import grpc
+import io
+import json
+import socket
+import time
+
+from concurrent import futures
+from typing import Callable, List, Tuple
+
+import numpy as np
+import pandas as pd
+import polars as pl
+import pyarrow
+
+import kaggle_evaluation.core.generated.kaggle_evaluation_pb2 as kaggle_evaluation_proto
+import kaggle_evaluation.core.generated.kaggle_evaluation_pb2_grpc as kaggle_evaluation_grpc
+
+
+_SERVICE_CONFIG = {
+    # Service config proto: https://github.com/grpc/grpc-proto/blob/ec886024c2f7b7f597ba89d5b7d60c3f94627b17/grpc/service_config/service_config.proto#L377
+    'methodConfig': [
+        {
+            'name': [{}],  # Applies to all methods
+            # See retry policy docs: https://grpc.io/docs/guides/retry/
+            'retryPolicy': {
+                'maxAttempts': 5,
+                'initialBackoff': '0.1s',
+                'maxBackoff': '1s',
+                'backoffMultiplier': 1, # Ensure relatively rapid feedback in the event of a crash
+                'retryableStatusCodes': ['UNAVAILABLE'],
+            },
+        }
+    ]
+}
+_GRPC_PORT = 50051
+_GRPC_CHANNEL_OPTIONS = [
+    # -1 for unlimited message send/receive size
+    # https://github.com/grpc/grpc/blob/v1.64.x/include/grpc/impl/channel_arg_names.h#L39
+    ('grpc.max_send_message_length', -1),
+    ('grpc.max_receive_message_length', -1),
+    # https://github.com/grpc/grpc/blob/master/doc/keepalive.md
+    ('grpc.keepalive_time_ms', 60_000),  # Time between heartbeat pings
+    ('grpc.keepalive_timeout_ms', 5_000),  # Time allowed to respond to pings
+    ('grpc.http2.max_pings_without_data', 0), # Remove another cap on pings
+    ('grpc.keepalive_permit_without_calls', 1), # Allow heartbeat pings at any time
+    ('grpc.http2.min_ping_interval_without_data_ms', 1_000),
+    ('grpc.service_config', json.dumps(_SERVICE_CONFIG)),
+]
+
+
+DEFAULT_DEADLINE_SECONDS = 60 * 60
+_RETRY_SLEEP_SECONDS = 1
+# Enforce a relatively strict server startup time so users can get feedback quickly if they're not
+# configuring KaggleEvaluation correctly. We really don't want notebooks timing out after nine hours
+# somebody forgot to start their inference_server. Slow steps like loading models
+# can happen during the first inference call if necessary.
+STARTUP_LIMIT_SECONDS = 60 * 15
+
+### Utils shared by client and server for data transfer
+
+# pl.Enum is currently unstable, but we should eventually consider supporting it.
+# https://docs.pola.rs/api/python/stable/reference/api/polars.datatypes.Enum.html#polars.datatypes.Enum
+_POLARS_TYPE_DENYLIST = set([pl.Enum, pl.Object, pl.Unknown])
+
+def _serialize(data) -> kaggle_evaluation_proto.Payload:
+    '''Maps input data of one of several allow-listed types to a protobuf message to be sent over gRPC.
+
+    Args:
+        data: The input data to be mapped. Any of the types listed below are accepted.
+
+    Returns:
+        The Payload protobuf message.
+
+    Raises:
+        TypeError if data is of an unsupported type.
+    '''
+    # Python primitives and Numpy scalars
+    if isinstance(data, np.generic):
+        # Numpy functions that return a single number return numpy scalars instead of python primitives.
+        # In some cases this difference matters: https://numpy.org/devdocs/release/2.0.0-notes.html#representation-of-numpy-scalars-changed
+        # Ex: np.mean(1,2) yields np.float64(1.5) instead of 1.5.
+        # Check for numpy scalars first since most of them also inherit from python primitives.
+        # For example, `np.float64(1.5)` is an instance of `float` among many other things.
+        # https://numpy.org/doc/stable/reference/arrays.scalars.html
+        assert data.shape == ()  # Additional validation that the np.generic type remains solely for scalars
+        assert isinstance(data, np.number) or isinstance(data, np.bool_)  # No support for bytes, strings, objects, etc
+        buffer = io.BytesIO()
+        np.save(buffer, data, allow_pickle=False)
+        return kaggle_evaluation_proto.Payload(numpy_scalar_value=buffer.getvalue())
+    elif isinstance(data, str):
+        return kaggle_evaluation_proto.Payload(str_value=data)
+    elif isinstance(data, bool): # bool is a subclass of int, so check that first
+        return kaggle_evaluation_proto.Payload(bool_value=data)
+    elif isinstance(data, int):
+        return kaggle_evaluation_proto.Payload(int_value=data)
+    elif isinstance(data, float):
+        return kaggle_evaluation_proto.Payload(float_value=data)
+    elif data is None:
+        return kaggle_evaluation_proto.Payload(none_value=True)
+    # Iterables for nested types
+    if isinstance(data, list):
+        return kaggle_evaluation_proto.Payload(list_value=kaggle_evaluation_proto.PayloadList(payloads=map(_serialize, data)))
+    elif isinstance(data, tuple):
+        return kaggle_evaluation_proto.Payload(tuple_value=kaggle_evaluation_proto.PayloadList(payloads=map(_serialize, data)))
+    elif isinstance(data, dict):
+        serialized_dict = {}
+        for key, value in data.items():
+            if not isinstance(key, str):
+                raise TypeError(f'KaggleEvaluation only supports dicts with keys of type str, found {type(key)}.')
+            serialized_dict[key] = _serialize(value)
+        return kaggle_evaluation_proto.Payload(dict_value=kaggle_evaluation_proto.PayloadMap(payload_map=serialized_dict))
+    # Allowlisted special types
+    if isinstance(data, pd.DataFrame):
+        buffer = io.BytesIO()
+        data.to_parquet(buffer, index=False, compression='lz4')
+        return kaggle_evaluation_proto.Payload(pandas_dataframe_value=buffer.getvalue())
+    elif isinstance(data, pl.DataFrame):
+        data_types = set(i.base_type() for i in data.dtypes)
+        banned_types = _POLARS_TYPE_DENYLIST.intersection(data_types)
+        if len(banned_types) > 0:
+            raise TypeError(f'Unsupported Polars data type(s): {banned_types}')
+
+        table = data.to_arrow()
+        buffer = io.BytesIO()
+        with pyarrow.ipc.new_stream(buffer, table.schema, options=pyarrow.ipc.IpcWriteOptions(compression='lz4')) as writer:
+            writer.write_table(table)
+        return kaggle_evaluation_proto.Payload(polars_dataframe_value=buffer.getvalue())
+    elif isinstance(data, pd.Series):
+        buffer = io.BytesIO()
+        # Can't serialize a pd.Series directly to parquet, must use intermediate DataFrame
+        pd.DataFrame(data).to_parquet(buffer, index=False, compression='lz4')
+        return kaggle_evaluation_proto.Payload(pandas_series_value=buffer.getvalue())
+    elif isinstance(data, pl.Series):
+        buffer = io.BytesIO()
+        # Can't serialize a pl.Series directly to parquet, must use intermediate DataFrame
+        pl.DataFrame(data).write_parquet(buffer, compression='lz4', statistics=False)
+        return kaggle_evaluation_proto.Payload(polars_series_value=buffer.getvalue())
+    elif isinstance(data, np.ndarray):
+        buffer = io.BytesIO()
+        np.save(buffer, data, allow_pickle=False)
+        return kaggle_evaluation_proto.Payload(numpy_array_value=buffer.getvalue())
+    elif isinstance(data, io.BytesIO):
+        return kaggle_evaluation_proto.Payload(bytes_io_value=data.getvalue())
+
+    raise TypeError(f'Type {type(data)} not supported for KaggleEvaluation.')
+
+
+def _deserialize(payload: kaggle_evaluation_proto.Payload):
+    '''Maps a Payload protobuf message to a value of whichever type was set on the message.
+
+    Args:
+        payload: The message to be mapped.
+
+    Returns:
+        A value of one of several allow-listed types.
+
+    Raises:
+        TypeError if an unexpected value data type is found.
+    '''
+    # Primitives
+    if payload.WhichOneof('value') == 'str_value':
+        return payload.str_value
+    elif payload.WhichOneof('value') == 'bool_value':
+        return payload.bool_value
+    elif payload.WhichOneof('value') == 'int_value':
+        return payload.int_value
+    elif payload.WhichOneof('value') == 'float_value':
+        return payload.float_value
+    elif payload.WhichOneof('value') == 'none_value':
+        return None
+    # Iterables for nested types
+    elif payload.WhichOneof('value') == 'list_value':
+        return list(map(_deserialize, payload.list_value.payloads))
+    elif payload.WhichOneof('value') == 'tuple_value':
+        return tuple(map(_deserialize, payload.tuple_value.payloads))
+    elif payload.WhichOneof('value') == 'dict_value':
+        return {key: _deserialize(value) for key, value in payload.dict_value.payload_map.items()}
+    # Allowlisted special types
+    elif payload.WhichOneof('value') == 'pandas_dataframe_value':
+        return pd.read_parquet(io.BytesIO(payload.pandas_dataframe_value))
+    elif payload.WhichOneof('value') == 'polars_dataframe_value':
+        with pyarrow.ipc.open_stream(payload.polars_dataframe_value) as reader:
+            table = reader.read_all()
+        return pl.from_arrow(table)
+    elif payload.WhichOneof('value') == 'pandas_series_value':
+        # Pandas will still read a single column csv as a DataFrame.
+        df = pd.read_parquet(io.BytesIO(payload.pandas_series_value))
+        return pd.Series(df[df.columns[0]])
+    elif payload.WhichOneof('value') == 'polars_series_value':
+        return pl.Series(pl.read_parquet(io.BytesIO(payload.polars_series_value)))
+    elif payload.WhichOneof('value') == 'numpy_array_value':
+        return np.load(io.BytesIO(payload.numpy_array_value), allow_pickle=False)
+    elif payload.WhichOneof('value') == 'numpy_scalar_value':
+        data = np.load(io.BytesIO(payload.numpy_scalar_value), allow_pickle=False)
+        # As of Numpy 2.0.2, np.load for a numpy scalar yields a dimensionless array instead of a scalar
+        data = data.dtype.type(data) # Restore the expected numpy scalar type.
+        assert data.shape == ()  # Additional validation that the np.generic type remains solely for scalars
+        assert isinstance(data, np.number) or isinstance(data, np.bool_)  # No support for bytes, strings, objects, etc
+        return data
+    elif payload.WhichOneof('value') == 'bytes_io_value':
+        return io.BytesIO(payload.bytes_io_value)
+
+    raise TypeError(f'Found unknown Payload case {payload.WhichOneof("value")}')
+
+### Client code
+
+class Client():
+    '''
+    Class which allows callers to make KaggleEvaluation requests.
+    '''
+    def __init__(self, channel_address: str='localhost'):
+        self.channel_address = channel_address
+        self.channel = grpc.insecure_channel(f'{channel_address}:{_GRPC_PORT}', options=_GRPC_CHANNEL_OPTIONS)
+        self._made_first_connection = False
+        self.endpoint_deadline_seconds = DEFAULT_DEADLINE_SECONDS
+        self.stub = kaggle_evaluation_grpc.KaggleEvaluationServiceStub(self.channel)
+
+    def _send_with_deadline(self, request):
+        ''' Sends a message to the server while also:
+        - Throwing an error as soon as the inference_server container has been shut down.
+        - Setting a deadline of STARTUP_LIMIT_SECONDS for the inference_server to startup.
+        '''
+        if self._made_first_connection:
+            return self.stub.Send(request, wait_for_ready=False, timeout=self.endpoint_deadline_seconds)
+
+        first_call_time = time.time()
+        # Allow time for the server to start as long as its container is running
+        while time.time() - first_call_time < STARTUP_LIMIT_SECONDS:
+            try:
+                response = self.stub.Send(request, wait_for_ready=False)
+                self._made_first_connection = True
+                break
+            except grpc._channel._InactiveRpcError as err:
+                if 'StatusCode.UNAVAILABLE' not in str(err):
+                    raise err
+            # Confirm the inference_server container is still alive & it's worth waiting on the server.
+            # If the inference_server container is no longer running this will throw a socket.gaierror.
+            socket.gethostbyname(self.channel_address)
+            time.sleep(_RETRY_SLEEP_SECONDS)
+
+        if not self._made_first_connection:
+            raise RuntimeError(f'Failed to connect to server after waiting {STARTUP_LIMIT_SECONDS} seconds')
+        return response
+
+    def send(self, name: str, *args, **kwargs):
+        '''Sends a single KaggleEvaluation request.
+
+        Args:
+            name: The endpoint name for the request.
+            *args: Variable-length/type arguments to be supplied on the request.
+            **kwargs: Key-value arguments to be supplied on the request.
+
+        Returns:
+            The response, which is of one of several allow-listed data types.
+        '''
+        request = kaggle_evaluation_proto.KaggleEvaluationRequest(
+                name=name,
+                args=map(_serialize, args),
+                kwargs={key: _serialize(value) for key, value in kwargs.items()}
+        )
+        response = self._send_with_deadline(request)
+
+        return _deserialize(response.payload)
+
+    def close(self):
+        self.channel.close()
+
+
+### Server code
+
+class KaggleEvaluationServiceServicer(kaggle_evaluation_grpc.KaggleEvaluationServiceServicer):
+    '''
+    Class which allows serving responses to KaggleEvaluation requests. The inference_server will run this service to listen for and respond
+    to requests from the Gateway. The Gateway may also listen for requests from the inference_server in some cases.
+    '''
+    def __init__(self, listeners: List[callable]):
+        self.listeners_map = dict((func.__name__, func) for func in listeners)
+
+    # pylint: disable=unused-argument
+    def Send(self, request: kaggle_evaluation_proto.KaggleEvaluationRequest, context: grpc.ServicerContext) -> kaggle_evaluation_proto.KaggleEvaluationResponse:
+        '''Handler for gRPC requests that deserializes arguments, calls a user-registered function for handling the
+        requested endpoint, then serializes and returns the response.
+
+        Args:
+            request: The KaggleEvaluationRequest protobuf message.
+            context: (Unused) gRPC context.
+
+        Returns:
+            The KaggleEvaluationResponse protobuf message.
+
+        Raises:
+            NotImplementedError if the caller has not registered a handler for the requested endpoint.
+        '''
+        if request.name not in self.listeners_map:
+            raise NotImplementedError(f'No listener for {request.name} was registered.')
+
+        args = map(_deserialize, request.args)
+        kwargs = {key: _deserialize(value) for key, value in request.kwargs.items()}
+        response_function = self.listeners_map[request.name]
+        response_payload = _serialize(response_function(*args, **kwargs))
+        return kaggle_evaluation_proto.KaggleEvaluationResponse(payload=response_payload)
+
+def define_server(*endpoint_listeners: Tuple[Callable]) -> grpc.server:
+    '''Registers the endpoints that the container is able to respond to, then starts a server which listens for
+    those endpoints. The endpoints that need to be implemented will depend on the specific competition.
+
+    Args:
+        endpoint_listeners: Tuple of functions that define how requests to the endpoint of the function name should be
+            handled.
+
+    Returns:
+        The gRPC server object, which has been started. It should be stopped at exit time.
+
+    Raises:
+        ValueError if parameter values are invalid.
+    '''
+    if not endpoint_listeners:
+        raise ValueError('Must pass at least one endpoint listener, e.g. `predict`')
+    for func in endpoint_listeners:
+        if not isinstance(func, Callable):
+            raise ValueError('Endpoint listeners passed to `serve` must be functions')
+        if func.__name__ == '<lambda>':
+            raise ValueError('Functions passed as endpoint listeners must be named')
+
+    server = grpc.server(futures.ThreadPoolExecutor(max_workers=1), options=_GRPC_CHANNEL_OPTIONS)
+    kaggle_evaluation_grpc.add_KaggleEvaluationServiceServicer_to_server(KaggleEvaluationServiceServicer(endpoint_listeners), server)
+    server.add_insecure_port(f'[::]:{_GRPC_PORT}')
+    return server

kaggle_evaluation/core/templates.py

@@ -0,0 +1,143 @@
+'''Template for the two classes hosts should customize for each competition.'''
+
+import abc
+import os
+import time
+import sys
+import traceback
+import warnings
+
+from typing import Callable, Generator, Tuple
+
+import kaggle_evaluation.core.base_gateway
+import kaggle_evaluation.core.relay
+
+_initial_import_time = time.time()
+_issued_startup_time_warning = False
+
+
+class Gateway(kaggle_evaluation.core.base_gateway.BaseGateway, abc.ABC):
+    '''
+    Template to start with when writing a new gateway.
+    In most cases, hosts should only need to write get_all_predictions.
+    There are two main methods for sending data to the inference_server hosts should understand:
+    - Small datasets: use `self.predict`. Competitors will receive the data passed to self.predict as
+    Python objects in memory. This is just a wrapper for self.client.send(); you can write additional
+    wrappers if necessary.
+    - Large datasets: it's much faster to send data via self.share_files, which is equivalent to making
+    files available via symlink. See base_gateway.BaseGateway.share_files for the full details.
+    '''
+    @abc.abstractmethod
+    def unpack_data_paths(self):
+        ''' Map the contents of self.data_paths to the competition-specific entries
+        Each competition should respect these paths to make it easy for competitors to
+        run tests on their local machines or with custom files.
+
+        Should include default paths to support data_paths = None.
+        '''
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def generate_data_batches(self) -> Generator:
+        ''' Used by the default implementation of `get_all_predictions` so we can
+        ensure `validate_prediction_batch` is run every time `predict` is called.
+
+        This method must yield both the batch of data to be sent to `predict` and the validation
+        data sent to `validate_prediction_batch`.
+        '''
+        raise NotImplementedError
+
+    def get_all_predictions(self):
+        all_predictions = []
+        for data_batch, validation_batch in self.generate_data_batches():
+            predictions = self.predict(*data_batch)
+            self.validate_prediction_batch(predictions, validation_batch)
+            all_predictions.append(predictions)
+        return all_predictions
+
+    def predict(self, *args, **kwargs):
+        ''' self.predict will send all data in args and kwargs to the user container, and
+        instruct the user container to generate a `predict` response.
+
+        '''
+        try:
+            return self.client.send('predict', *args, **kwargs)
+        except Exception as e:
+            self.handle_server_error(e, 'predict')
+
+    def set_response_timeout_seconds(self, timeout_seconds: float=6_000):
+        # Set a response deadline that will apply after the very first repsonse
+        self.client.endpoint_deadline_seconds = timeout_seconds
+
+    def run(self):
+        error = None
+        try:
+            self.unpack_data_paths()
+            predictions = self.get_all_predictions()
+            self.write_submission(predictions)
+        except kaggle_evaluation.core.base_gateway.GatewayRuntimeError as gre:
+            error = gre
+        except Exception:
+            # Get the full stack trace
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            error_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+
+            error = kaggle_evaluation.core.base_gateway.GatewayRuntimeError(
+                kaggle_evaluation.core.base_gateway.GatewayRuntimeErrorType.GATEWAY_RAISED_EXCEPTION,
+                error_str
+            )
+
+        self.client.close()
+        if self.server:
+            self.server.stop(0)
+
+        if kaggle_evaluation.core.base_gateway.IS_RERUN:
+            self.write_result(error)
+        elif error:
+            # For local testing
+            raise error
+
+
+class InferenceServer(abc.ABC):
+    '''
+    Base class for competition participants to inherit from when writing their submission. In most cases, users should
+    only need to implement a `predict` function or other endpoints to pass to this class's constructor, and hosts will
+    provide a mock Gateway for testing.
+    '''
+    def __init__(self, endpoint_listeners: Tuple[Callable]):
+        self.server = kaggle_evaluation.core.relay.define_server(endpoint_listeners)
+        self.client = None  # The inference_server can have a client but it isn't typically necessary.
+        self._issued_startup_time_warning = False
+        self._startup_limit_seconds = kaggle_evaluation.core.relay.STARTUP_LIMIT_SECONDS
+
+    def serve(self):
+        self.server.start()
+        if os.getenv('KAGGLE_IS_COMPETITION_RERUN') is not None:
+            self.server.wait_for_termination()  # This will block all other code
+
+    @abc.abstractmethod
+    def _get_gateway_for_test(self, data_paths):
+        # TODO: This should return a version of the competition-specific gateway that's able to load
+        # data used for unit tests.
+        raise NotImplementedError
+
+    def run_local_gateway(self, data_paths=None):
+        global _issued_startup_time_warning
+        script_elapsed_seconds = time.time() - _initial_import_time
+        if script_elapsed_seconds > self._startup_limit_seconds and not _issued_startup_time_warning:
+            warnings.warn(
+                f'''{int(script_elapsed_seconds)} seconds elapsed before server startup.
+                This exceeds the startup time limit of {int(self._startup_limit_seconds)} seconds that the gateway will enforce
+                during the rerun on the hidden test set. Start the server before performing any time consuming steps.''',
+                category=RuntimeWarning
+            )
+            _issued_startup_time_warning = True
+
+        self.server.start()
+        try:
+            self.gateway = self._get_gateway_for_test(data_paths)
+            self.gateway.run()
+        except Exception as err:
+            raise err from None
+        finally:
+            self.server.stop(0)

kaggle_evaluation/jane_street_gateway.py

@@ -0,0 +1,57 @@
+"""Gateway notebook for https://www.kaggle.com/competitions/jane-street-real-time-market-data-forecasting"""
+
+import os
+
+import kaggle_evaluation.core.base_gateway
+import kaggle_evaluation.core.templates
+import polars as pl
+
+
+class JSGateway(kaggle_evaluation.core.templates.Gateway):
+    def __init__(self, data_paths: tuple[str, str] | None = None):
+        super().__init__(data_paths, file_share_dir=None)
+        self.data_paths = data_paths
+        self.set_response_timeout_seconds(60)
+
+    def unpack_data_paths(self):
+        if not self.data_paths:
+            self.test_path = (
+                "/kaggle/input/jane-street-realtime-marketdata-forecasting/test.parquet"
+            )
+            self.lags_path = (
+                "/kaggle/input/jane-street-realtime-marketdata-forecasting/lags.parquet"
+            )
+        else:
+            self.test_path, self.lags_path = self.data_paths
+
+    def generate_data_batches(self):
+        date_ids = sorted(
+            pl.scan_parquet(self.test_path)
+            .select(pl.col("date_id").unique())
+            .collect()
+            .get_column("date_id")
+        )
+        assert date_ids[0] == 0
+
+        for date_id in date_ids:
+            test_batches = pl.read_parquet(
+                os.path.join(self.test_path, f"date_id={date_id}"),
+            ).group_by("time_id", maintain_order=True)
+
+            lags = pl.read_parquet(
+                os.path.join(self.lags_path, f"date_id={date_id}"),
+            )
+
+            for (time_id,), test in test_batches:
+                test_data = (test, lags if time_id == 0 else None)
+                validation_data = test.select('row_id')
+                yield test_data, validation_data
+
+
+if __name__ == "__main__":
+    if os.getenv("KAGGLE_IS_COMPETITION_RERUN"):
+        gateway = JSGateway()
+        # Relies on valid default data paths
+        gateway.run()
+    else:
+        print("Skipping run for now")

kaggle_evaluation/jane_street_inference_server.py

@@ -0,0 +1,9 @@
+
+import kaggle_evaluation.core.templates
+
+import jane_street_gateway
+
+
+class JSInferenceServer(kaggle_evaluation.core.templates.InferenceServer):
+    def _get_gateway_for_test(self, data_paths=None):
+        return jane_street_gateway.JSGateway(data_paths)

lags.parquet/.DS_Store

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:189f13537da47c0531de399d77a57f11df733d7fbef684d5b38f62918b03470e
+size 6148

lags.parquet/date_id=0/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f9492d4475c5d06725019fd037d0e61ab9cede5a4d49293bd874a95f3c7813bb
+size 5752

test.parquet/.DS_Store

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d663248193e5b378048c20c00c5e1d480a9cf788a05fed70a2539e98b1d3a156
+size 6148

test.parquet/date_id=0/part-0.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5b73c5a30da6d6cd386c9d28cd7cb43b40a877ffdb7ab4420d7b0b8eac19c9b6
+size 28165