chalkpy 2.94.2__py3-none-any.whl → 2.94.4__py3-none-any.whl

chalk/__init__.py

@@ -26,7 +26,7 @@ from chalk.features._document import Document
 from chalk.features._last import Last
 from chalk.features.filter import freeze_time
 from chalk.features.pseudofeatures import Distance, Now
-from chalk.features.resolver import OfflineResolver, OnlineResolver, Resolver, offline, online
+from chalk.features.resolver import OfflineResolver, OnlineResolver, Resolver, make_model_resolver, offline, online
 from chalk.features.tag import BranchId, EnvironmentId
 from chalk.features.underscore import _, __, underscore
 from chalk.importer import get_resolver
@@ -98,6 +98,7 @@ __all__ = (
     "has_many",
     "has_one",
     "is_primary",
+    "make_model_resolver",
     "make_sql_file_resolver",
     "offline",
     "online",

chalk/_version.py

@@ -1 +1 @@
-__version__ = "2.94.2"
+__version__ = "2.94.4"

chalk/features/inference.py

@@ -12,7 +12,7 @@ from chalk.utils.collections import ensure_tuple
 
 
 def build_inference_function(
-    model_version: ModelVersion, pkey: Feature, output_feature: Optional[Feature] = None
+    model_version: ModelVersion, pkey: Feature, output_features: Optional[Feature | list[Feature]] = None
 ) -> Callable[[DataFrame], DataFrame]:
     """Build the core inference function that takes a DataFrame and returns predictions.
 
@@ -24,8 +24,9 @@ def build_inference_function(
         The model version to use for prediction
     pkey
         The primary key feature to exclude from predictions
-    output_feature
-        Optional output feature to add predictions to the DataFrame
+    output_features
+        Optional output feature(s) to add predictions to the DataFrame.
+        Can be a single Feature or a list of Features for multi-output models.
 
     Returns
     -------
@@ -45,11 +46,19 @@ def build_inference_function(
         # Run prediction
         result = model_version.predict(model_input)
 
-        if output_feature is not None:
-            # Use model-specific output extraction (default: identity, ONNX: extract field)
-            output_feature_name = str(output_feature).split(".")[-1]
-            result_data = model_version.predictor.extract_output(result, output_feature_name)
-            return inp[pkey_string].with_columns({output_feature: result_data})
+        if output_features is not None:
+            # Normalize to list for uniform processing
+            features_list = output_features if isinstance(output_features, list) else [output_features]
+
+            # Extract output for each feature and build columns dict
+            columns_dict = {}
+            for output_feature in features_list:
+                # Use model-specific output extraction (default: identity, ONNX: extract field)
+                output_feature_name = str(output_feature).split(".")[-1]
+                result_data = model_version.predictor.extract_output(result, output_feature_name)
+                columns_dict[output_feature] = result_data
+
+            return inp[pkey_string].with_columns(columns_dict)
 
         return result
 

chalk/features/resolver.py

@@ -115,6 +115,7 @@ if TYPE_CHECKING:
 
     from chalk.features import Underscore
     from chalk.features.underscore import UnderscoreAttr, UnderscoreCall, UnderscoreCast, UnderscoreFunction
+    from chalk.ml.model_version import ModelVersion
     from chalk.sql import BaseSQLSourceProtocol, SQLSourceGroup
     from chalk.sql._internal.sql_settings import SQLResolverSettings
     from chalk.sql._internal.sql_source import BaseSQLSource
@@ -4478,3 +4479,184 @@ def validate_message_attributes(
         message_type = message_type.__args__[0]  # pyright: ignore[reportAttributeAccessIssue]
     for expression in expressions:
         validate_underscore_expression(expression, message_type, error_builder, name)
+
+
+def make_model_resolver(
+    name: str,
+    model: "ModelVersion",
+    inputs: Dict[Feature, str] | List[Feature],
+    output: Feature | List[Feature] | Dict[Feature, str],
+    feature_class: Optional[type[Features]] = None,
+    resource_group: Optional[str] = None,
+    resource_hint: Optional[ResourceHint] = None,
+) -> OnlineResolver:
+    """
+    Create an online resolver that runs inference on a model.
+
+    This function provides an imperative API for creating model inference resolvers,
+    as an alternative to using F.inference in feature definitions. It uses the same
+    underlying implementation as F.inference but allows you to create resolvers
+    programmatically.
+
+    Parameters
+    ----------
+    name
+        The name of the resolver
+    model
+        A ModelVersion reference to a deployed model
+    inputs
+        Either a dict mapping Feature objects to model input names (strings), or a list of
+        Feature objects. If a dict, the values represent the model's expected input names
+        (for future use). If a list, the features will be passed as a single DataFrame to
+        the model.
+    output
+        The output feature(s) that will contain the predictions.
+        Can be a single Feature, a list of Features, or a dict mapping Feature objects to
+        model output names (strings) for future use with multi-output models.
+    feature_class
+        Optional feature class to use. If not provided, will be inferred from the inputs.
+    resource_group
+        Optional resource group for the resolver
+    resource_hint
+        Optional resource hint for execution (e.g., CPU/GPU preferences)
+
+    Returns
+    -------
+    OnlineResolver
+        The created resolver
+
+    Examples
+    --------
+    >>> from chalk.features import features, feature
+    >>> from chalk.features.resolver import make_model_resolver
+    >>> from chalk.ml import ModelVersion
+    >>>
+    >>> @features
+    ... class User:
+    ...     id: str = feature(primary=True)
+    ...     age: float
+    ...     income: float
+    ...     risk_score: float
+    ...     credit_score: float
+    >>>
+    >>> # Create a model version reference
+    >>> model = ModelVersion(
+    ...     name="risk_model",
+    ...     version=1,
+    ...     model_type="sklearn",
+    ...     model_encoding="pickle",
+    ...     filename="model.pkl"
+    ... )
+    >>>
+    >>> # Create resolver with single output
+    >>> resolver = make_model_resolver(
+    ...     name="risk_model",
+    ...     model=model,
+    ...     inputs=[User.age, User.income],
+    ...     output=User.risk_score,
+    ... )
+    >>>
+    >>> # Create resolver with multiple outputs (list)
+    >>> resolver = make_model_resolver(
+    ...     name="multi_output_model",
+    ...     model=model,
+    ...     inputs=[User.age, User.income],
+    ...     output=[User.risk_score, User.credit_score],
+    ... )
+    >>>
+    >>> # Create resolver with named inputs and outputs (dict)
+    >>> resolver = make_model_resolver(
+    ...     name="named_model",
+    ...     model=model,
+    ...     inputs={User.age: "age_input", User.income: "income_input"},
+    ...     output={User.risk_score: "risk_output", User.credit_score: "credit_output"},
+    ... )
+    """
+    from chalk.features.inference import build_inference_function
+
+    if isinstance(inputs, dict):
+        input_features_raw = list(inputs.keys())
+    else:
+        input_features_raw = inputs
+
+    input_features = [unwrap_feature(f) for f in input_features_raw]
+
+    if isinstance(output, dict):
+        output_features = [unwrap_feature(f) for f in output.keys()]
+    elif isinstance(output, list):
+        output_features = [unwrap_feature(f) for f in output]
+    else:
+        output_features = [unwrap_feature(output)]
+
+    # If feature_class is not provided, try to infer it from the first input feature
+    if feature_class is None:
+        if not input_features:
+            raise ValueError("Cannot infer feature class: no input features provided and feature_class not specified")
+
+        first_input = input_features[0]
+
+        if hasattr(first_input, "features_cls") and first_input.features_cls is not None:
+            feature_class = first_input.features_cls
+        else:
+            raise ValueError(
+                "Cannot infer feature class from inputs. Please provide feature_class parameter explicitly."
+            )
+
+    pkey = feature_class.__chalk_primary__
+    if pkey is None:
+        raise ValueError(f"Feature class {feature_class} does not have a primary key defined")
+
+    first_output = output_features[0]
+
+    output_namespace = (
+        first_output.namespace
+        if hasattr(first_output, "namespace") and first_output.namespace
+        else feature_class.__name__.lower()
+    )
+
+    # Use the same underlying inference function as F.inference
+    # Pass list of outputs if multiple, single if only one
+    output_for_inference = output_features if len(output_features) > 1 else output_features[0]
+    inference_fn = build_inference_function(model, pkey, output_for_inference)
+
+    if len(output_features) == 1:
+        output_names = output_features[0].name
+    else:
+        output_names = "_".join(f.name for f in output_features)
+
+    resolver = OnlineResolver(
+        function_definition="",
+        filename="",
+        fqn=f"{name}__{output_namespace}_{output_names}",
+        doc=None,
+        inputs=[DataFrame[[pkey, *ensure_tuple(input_features)]]],
+        state=None,
+        output=Features[DataFrame[tuple([*output_features, pkey])]],  # type: ignore[misc]
+        fn=inference_fn,
+        environment=None,
+        machine_type=None,
+        default_args=[None],
+        timeout=None,
+        cron=None,
+        when=None,
+        tags=None,
+        owner=None,
+        resource_hint=resource_hint or model.resource_hint,
+        data_sources=None,
+        is_sql_file_resolver=False,
+        source_line=None,
+        lsp_builder=get_resolver_error_builder(inference_fn),
+        parse=None,
+        static=False,
+        total=False,
+        autogenerated=False,
+        unique_on=None,
+        partitioned_by=None,
+        data_lineage=None,
+        sql_settings=None,
+    )
+
+    # Register the resolver
+    RESOLVER_REGISTRY.add_to_registry(resolver, override=False)
+
+    return resolver

chalk/ml/__init__.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from chalk.ml.model_file_transfer import FileInfo, HFSourceConfig, LocalSourceConfig, S3SourceConfig, SourceConfig
 from chalk.ml.model_reference import ModelReference
+from chalk.ml.model_version import ModelVersion
 from chalk.ml.utils import ModelClass, ModelEncoding, ModelRunCriterion, ModelType
 
 __all__ = (
@@ -9,6 +10,7 @@ __all__ = (
     "ModelClass",
     "ModelEncoding",
     "ModelReference",
+    "ModelVersion",
     "SourceConfig",
     "LocalSourceConfig",
     "S3SourceConfig",

chalk/sql/_internal/sql_source.py

@@ -214,11 +214,32 @@ class BaseSQLSource(BaseSQLSourceProtocol):
         if getattr(self, "kind", None) != SQLSourceKind.trino:
             engine_args.setdefault("pool_pre_ping", env_var_bool("USE_CLIENT_POOL_PRE_PING"))
             async_engine_args.setdefault("pool_pre_ping", env_var_bool("USE_CLIENT_POOL_PRE_PING"))
-        self.engine_args = engine_args
-        self.async_engine_args = async_engine_args
+        # Store raw args internally, expose filtered versions via properties
+        self._raw_engine_args = engine_args
+        self._raw_async_engine_args = async_engine_args
         self._engine = None
         self._async_engine = None
 
+    @property
+    def engine_args(self) -> Dict[str, Any]:
+        """Engine arguments with native_args filtered out for SQLAlchemy."""
+        return {k: v for k, v in self._raw_engine_args.items() if k != "native_args"}
+
+    @engine_args.setter
+    def engine_args(self, args: dict[str, Any]):
+        """Set raw engine args (for backward compatibility)."""
+        self._raw_engine_args = args
+
+    @property
+    def async_engine_args(self) -> Dict[str, Any]:
+        """Async engine arguments with native_args filtered out for SQLAlchemy."""
+        return {k: v for k, v in self._raw_async_engine_args.items() if k != "native_args"}
+
+    @async_engine_args.setter
+    def async_engine_args(self, args: dict[str, Any]):
+        """Set raw async engine args (for backward compatibility)."""
+        self._raw_async_engine_args = args
+
     @property
     def _engine_args(self):
         """Backcompat support for private subclassing of BaseSQLSource"""
@@ -239,6 +260,16 @@ class BaseSQLSource(BaseSQLSourceProtocol):
         """Backcompat support for private subclassing of BaseSQLSource"""
         self.async_engine_args = args
 
+    @property
+    def native_args(self) -> Dict[str, Any]:
+        """Native arguments to be passed to the underlying database driver.
+
+        These arguments are extracted from engine_args and async_engine_args
+        and are not passed to SQLAlchemy's create_engine or create_async_engine.
+        Instead, they should be used by subclasses to configure native driver connections.
+        """
+        return self._raw_engine_args.get("native_args", {})
+
     def get_sqlglot_dialect(self) -> Union[str, None]:
         """Returns the name of the SQL dialect (if it has one) for `sqlglot` to parse the SQL string.
         This allows for use of dialect-specific syntax while parsing and modifying queries."""
@@ -832,6 +863,7 @@ class BaseSQLSource(BaseSQLSourceProtocol):
         if self._engine is None:
             self.register_sqlalchemy_compiler_overrides()
             self._check_engine_isolation_level()
+            # engine_args property already filters out native_args
             self._engine = create_engine(url=self.local_engine_url(), **self.engine_args)
         return self._engine
 
@@ -841,6 +873,7 @@ class BaseSQLSource(BaseSQLSourceProtocol):
         if self._async_engine is None:
             self.register_sqlalchemy_compiler_overrides()
             self._check_engine_isolation_level()
+            # async_engine_args property already filters out native_args
             self._async_engine = create_async_engine(url=self.async_local_engine_url(), **self.async_engine_args)
         return self._async_engine
 

chalk/utils/tracing.py

@@ -10,16 +10,21 @@ from typing import TYPE_CHECKING, Any, Mapping, Union, cast
 from chalk.utils._ddtrace_version import can_use_datadog_statsd, can_use_ddtrace
 from chalk.utils._otel_version import can_use_otel_trace
 from chalk.utils.environment_parsing import env_var_bool
+from chalk.utils.log_with_context import get_logger
 
 if TYPE_CHECKING:
     import ddtrace.context
     from opentelemetry import trace as otel_trace
 
+_logger = get_logger(__name__)
+
 if can_use_otel_trace:
     from opentelemetry import context as otel_context
     from opentelemetry import trace as otel_trace
     from opentelemetry.propagate import inject as otel_inject
 
+    _logger.debug("OTEL trace packages installed, otel tracing is available")
+
     @contextlib.contextmanager
     def safe_trace(span_id: str, attributes: Mapping[str, str] | None = None):  # pyright: ignore[reportRedeclaration]
         if attributes is None:
@@ -73,10 +78,12 @@ if can_use_otel_trace:
         otel_inject(headers, context=ctx)
         return headers
 
-elif can_use_ddtrace and can_use_datadog_statsd:
+elif can_use_ddtrace:
     import ddtrace
     from ddtrace.propagation.http import HTTPPropagator
 
+    _logger.debug("ddtrace installed and available, using it to trace")
+
     @contextlib.contextmanager
     def safe_trace(span_id: str, attributes: Mapping[str, str] | None = None):  # pyright: ignore[reportRedeclaration]
         if not ddtrace.tracer.enabled:
@@ -134,6 +141,7 @@ elif can_use_ddtrace and can_use_datadog_statsd:
         return headers
 
 else:
+    _logger.debug("no trace packages found, tracing will not work")
 
     @contextlib.contextmanager
     def safe_trace(span_id: str, attributes: Mapping[str, str] | None = None):  # pyright: ignore[reportRedeclaration]
@@ -283,3 +291,6 @@ def configure_tracing(default_service_name: str):
         )
     else:
         _logger.warning("neither opentelemetry nor ddtrace are installed")
+
+
+configure_tracing("chalkpy")

{chalkpy-2.94.2.dist-info → chalkpy-2.94.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalkpy
-Version: 2.94.2
+Version: 2.94.4
 Summary: Python SDK for Chalk
 Author: Chalk AI, Inc.
 Project-URL: Homepage, https://chalk.ai

{chalkpy-2.94.2.dist-info → chalkpy-2.94.4.dist-info}/RECORD

@@ -1,5 +1,5 @@
-chalk/__init__.py,sha256=9YxwkAt3Im0OCMfpmnIB_4PKjZfBCcRmwATLXdHNRm4,2609
-chalk/_version.py,sha256=IK5bNkpgNQmicBftniZwh9_JCF7TXuXH1aZ4bQTcQWI,23
+chalk/__init__.py,sha256=vKsx9-cl5kImlVWGHVRYO6bweBm79NAzGs3l36u71wM,2657
+chalk/_version.py,sha256=luYLQQ9SuJMxCYjx5Y4oiVD-k1_vNu6P83uTjbtFHlI,23
 chalk/cli.py,sha256=ckqqfOI-A2mT23-rnZzDMmblYj-2x1VBX8ebHlIEn9A,5873
 chalk/importer.py,sha256=m4lMn1lSYj_euDq8CS7LYTBnek9JOcjGJf9-82dJHbA,64441
 chalk/prompts.py,sha256=2H9UomLAamdfRTNUdKs9i3VTpiossuyRhntqsAXUhhg,16117
@@ -631,12 +631,12 @@ chalk/features/feature_time.py,sha256=iUk8NDelig81jP7QT3tguyzx5eOZ-YC84OVgJRRKVw
 chalk/features/feature_wrapper.py,sha256=OolNWGGX67IAEMHCObFvOCpH5EmwjbMvMygRSBJJtu0,19259
 chalk/features/filter.py,sha256=2ldMbqvXC-nJ0jc-OZ36qHtrej-Jkx4TNQ1W_NZodAs,11177
 chalk/features/hooks.py,sha256=KPJnudnhosEH7UptQT8W8sumIYPcZVMVjaJJJhPsOyk,5489
-chalk/features/inference.py,sha256=hQ6htPh6Q-XzfRjpEgMHKaCGwpKlnGG0wcxoGqwPQfo,4912
+chalk/features/inference.py,sha256=D1mieSj9AvVZ47tsf_gaipw_y4QnBVD6XU1AJedwTo0,5377
 chalk/features/live_updates.py,sha256=8ZbiDjcLqfFruSL15_aycwzSqJ0TbKNhas06KfZLyLU,3644
 chalk/features/namespace_context.py,sha256=fL-nPohqtNiyPDS1uQTAaHLns4aivuBL2Flf50DajU4,1813
 chalk/features/primary.py,sha256=BZ8mrMmKfRNy_wnKGDJt2cdnejP_CZb6xBsD9Ljgajc,5209
 chalk/features/pseudofeatures.py,sha256=50Pe_Xi8ttYWtgNNRpgkhBxP8xoCZCYwyLb0aWUQ-PI,2147
-chalk/features/resolver.py,sha256=wbY9Xdw1dsHMaP2FklOl_VGfYcgPluqWREORm6EggDo,182244
+chalk/features/resolver.py,sha256=B_iIP3wm-nfYCkW1ZuxFMH2rWZogwaYshrLSZqLR0oQ,188553
 chalk/features/tag.py,sha256=LRmKRA8ANCOvmaIAk-L5j1QW2U0aah2SeASy8Uydkmk,2675
 chalk/features/underscore.py,sha256=4xnfQV3bfvVn0PNEtkT4J-k7hW4ebtH9KBe4_BvGjY4,26763
 chalk/features/underscore_features.py,sha256=PlVCoaDDffOgtiSMaxPSWCoj8IjscbkOzDLA471HsJ4,13005
@@ -678,7 +678,7 @@ chalk/integrations/catalogs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 chalk/integrations/catalogs/base_catalog.py,sha256=CwfZZWRvLHJtbIdeRWtBvuXjbtKjUuOWaGxTfvVMlgU,237
 chalk/integrations/catalogs/glue_catalog.py,sha256=V0FzB_sy8espMAijnQpmTs-VSmmTLbTd_Ijn08RKrn4,5635
 chalk/logging/__init__.py,sha256=CpWJAO83W8kOwihQSqPEBTOCCJBJ7jo2JsHPr-JDjPc,746
-chalk/ml/__init__.py,sha256=Opo2xFrdlARwRgvnw3XDeccvpGmopthUp31-_I-3Cao,509
+chalk/ml/__init__.py,sha256=B7QkTqFBhNlHTTvLK5xa8sWA_UcF386S3V91TfQXMU4,577
 chalk/ml/chalk_train.py,sha256=B-Kr1_vKgaeUk8kIk7-8YYCDoWjYzQvgbAQHkkb8JCI,2335
 chalk/ml/model_file_transfer.py,sha256=tpD3tg1PI20bNSLwyE63wzFU4qeG4rLFt1sL0JRkzMs,9587
 chalk/ml/model_hooks.py,sha256=vAd8iqW5zarEl2nLAdhoPYuJxxThx2_UuZ4orK9b9kI,14927
@@ -729,7 +729,7 @@ chalk/sql/_internal/query_execution_parameters.py,sha256=FT0GixOryGeKR1x7UrQNoGF
 chalk/sql/_internal/query_registry.py,sha256=jOk2x9NvW2pZocI_iTvgd9DyOlr4-ajz8rTi0kkLSaI,3005
 chalk/sql/_internal/sql_file_resolver.py,sha256=BCGTpe3tVLQTWNSrfyUFsg8VfO-pupeN8yxGpiSmy5E,77817
 chalk/sql/_internal/sql_settings.py,sha256=9lcpHNrmEhr1Zxl_Ct7U0p0AbLUvlpSayxHEPmyqu8E,543
-chalk/sql/_internal/sql_source.py,sha256=D5GEYIBVyGpsb66qcXasJaldM6uhE4sZSaaTbYqd3Q4,42302
+chalk/sql/_internal/sql_source.py,sha256=083tGM7YzSsL-AhwTAtCzvGSjKxGVH_R5pILEpe5g1c,43825
 chalk/sql/_internal/sql_source_group.py,sha256=RIMEjEG3oSGwign37w9avpCRdVfVQepR8SPVv6JoOx0,5562
 chalk/sql/_internal/string_chalk_query.py,sha256=mfPoyP_-nUx8B_RvqJtIMoI0orGPknW7QYEHOb_jQII,4342
 chalk/sql/_internal/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -799,12 +799,12 @@ chalk/utils/storage_client.py,sha256=cK5KH8DVAt4Okk3X4jNMCkMiZgfUJE9Sq3zn4HkaBQo
 chalk/utils/string.py,sha256=mHciu1FR1NdXiE0GjiCOOs_Q3JBVpaNnjUQPorE5cJg,4268
 chalk/utils/stubgen.py,sha256=-mKIWFeiZojtfPwaTd9o3h4m4RvTmMTk6i-bI9JpU6c,21580
 chalk/utils/threading.py,sha256=dacvfFCpDs9GDWdRrE2mmM3Ex5DKOIaj5rCYDTqGshk,5305
-chalk/utils/tracing.py,sha256=Glx8YrtjWy0zE5YbpgfgcsLDshAKnnYm9poiWNeCxXs,11075
+chalk/utils/tracing.py,sha256=ye5z6UCEsrxXC3ofXUNCDdUCf8ydPahEO92qQTd0AIA,11383
 chalk/utils/weak_set_by_identity.py,sha256=VmikA_laYwFeOphCwXJIuyOIkrdlQe0bSzaXq7onoQw,953
 chalk/utils/pydanticutil/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chalk/utils/pydanticutil/pydantic_compat.py,sha256=O575lLYJ5GvZC4HMzR9yATxf9XwjC6NrDUXbNwZidlE,3031
-chalkpy-2.94.2.dist-info/METADATA,sha256=9sXDjSYVOMAQVoH3-lqfTsOLrJUQuewOsZuH9DpWt6s,27494
-chalkpy-2.94.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-chalkpy-2.94.2.dist-info/entry_points.txt,sha256=Vg23sd8icwq-morJrljVFr-kQnMbm95rZfZj5wsZGis,42
-chalkpy-2.94.2.dist-info/top_level.txt,sha256=1Q6_19IGYfNxSw50W8tYKEJ2t5HKQ3W9Wiw4ia5yg2c,6
-chalkpy-2.94.2.dist-info/RECORD,,
+chalkpy-2.94.4.dist-info/METADATA,sha256=H4Au5kWLocgZWNgy9_jBffgCfWQPqJZvdNBVWBaZHys,27494
+chalkpy-2.94.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chalkpy-2.94.4.dist-info/entry_points.txt,sha256=Vg23sd8icwq-morJrljVFr-kQnMbm95rZfZj5wsZGis,42
+chalkpy-2.94.4.dist-info/top_level.txt,sha256=1Q6_19IGYfNxSw50W8tYKEJ2t5HKQ3W9Wiw4ia5yg2c,6
+chalkpy-2.94.4.dist-info/RECORD,,