chalkpy 2.93.0__tar.gz → 2.93.2__tar.gz

{chalkpy-2.93.0 → chalkpy-2.93.2}/PKG-INFO

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

chalkpy-2.93.2/chalk/_version.py

@@ -0,0 +1 @@
+__version__ = "2.93.2"

{chalkpy-2.93.0 → chalkpy-2.93.2}/chalk/client/client.py

@@ -924,6 +924,8 @@ class ChalkClient:
         max_retries: int | None = None,
         query_name: str | None = None,
         query_name_version: str | None = None,
+        *,
+        input_sql: str | None = None,
     ) -> Dataset:
         """Compute feature values from the offline store or by running offline/online resolvers.
         See `Dataset` for more information.
@@ -944,6 +946,9 @@ class ChalkClient:
             times, the list must match the length of the `input` lists. Each element of input_time corresponds with the
             feature values at the same index of the `input` lists.
             See https://docs.chalk.ai/docs/temporal-consistency for more information.
+        input_sql
+            An alternative to `input`: a ChalkSQL query that returns values
+            to use as inputs.
         output
             The features that you'd like to sample, if they exist.
             If an output feature was never computed for a sample (row) in

{chalkpy-2.93.0 → chalkpy-2.93.2}/chalk/client/client_async.py

@@ -646,6 +646,8 @@ class AsyncChalkClient:
         max_retries: int | None = None,
         query_name: str | None = None,
         query_name_version: str | None = None,
+        *,
+        input_sql: str | None = None,
     ) -> Dataset:
         """Compute feature values from the offline store or by running offline/online resolvers.
         See `Dataset` for more information.
@@ -660,6 +662,9 @@ class AsyncChalkClient:
             an observation in line with the timestamp in `input_times`.
         input_times
             A list of the times of the observations from `input`.
+        input_sql
+            An alternative to `input`: a ChalkSQL query that returns values
+            to use as inputs.
         output
             The features that you'd like to sample, if they exist.
             If an output feature was never computed for a sample (row) in

{chalkpy-2.93.0 → chalkpy-2.93.2}/chalk/client/client_impl.py

@@ -103,6 +103,7 @@ from chalk.client.models import (
     MultiUploadFeaturesResponse,
     OfflineQueryContext,
     OfflineQueryInput,
+    OfflineQueryInputSql,
     OfflineQueryInputUri,
     OfflineQueryParquetUploadURLResponse,
     OnlineQuery,
@@ -2238,6 +2239,8 @@ https://docs.chalk.ai/cli/apply
         override_target_image_tag: Optional[str] = None,
         feature_for_lower_upper_bound: Optional[FeatureReference] = None,
         use_job_queue: bool = False,
+        *,
+        input_sql: str | None = None,
     ) -> DatasetImpl:
         run_asynchronously = (
             use_multiple_computers
@@ -2260,11 +2263,6 @@ https://docs.chalk.ai/cli/apply
         if query_name is None and query_name_version is not None:
             raise ValueError("Passed 'query_name_version' without 'query_name'.")
 
-        if max_samples is not None and input is not None:
-            raise ValueError(
-                "Cannot specify both 'max_samples' and 'input'. 'max_samples' is only valid when input is None."
-            )
-
         if isinstance(num_shards, int) and num_shards < 1:
             raise ValueError("num_shards must be greater than 0")
         if isinstance(num_workers, int) and num_workers < 1:
@@ -2285,48 +2283,70 @@ https://docs.chalk.ai/cli/apply
 
         context = OfflineQueryContext(environment=environment)
 
-        if input is None:
-            query_input = None
-        elif isinstance(input, OfflineQueryInputUri):
-            query_input = input
-        elif isinstance(input, str):
-            query_input = OfflineQueryInputUri(
-                parquet_uri=input,
-                start_row=None,
-                end_row=None,
-            )
-        else:
-            # by this point, should be
-            # Union[QueryInput, List[QueryInput], Tuple[QueryInput, ...]]
-            if isinstance(input, (list, tuple)):
-                input_times_tuple: Sequence[QueryInputTime] = (
-                    [None] * len(input)
-                    if input_times is None
-                    else [input_times for _ in input]
-                    if isinstance(input_times, datetime)
-                    else input_times
+        _check_exclusive_options(
+            {
+                "input": input,
+                "input_sql": input_sql,
+                "max_samples": max_samples,
+            }
+        )
+        if input_sql is not None:
+            if input_times is not None:
+                raise ValueError(
+                    f"Cannot specify `input_sql` and `input_times` together. Instead, the ChalkSQL query may output a `{TS_COL_NAME}` column"
                 )
-                run_asynchronously = True
-                multi_input = list(zip(input, input_times_tuple))
-            else:
-                # Just a QueryInput
-                multi_input = [(input, cast(None, input_times))]
+            if num_shards is not None:
+                raise ValueError("Cannot specify `input_sql` and `num_shards` together.")
+            if num_workers is not None:
+                raise ValueError("Cannot specify `input_sql` and `num_workers` together.")
 
-            # defaulting to uploading input as table if inputs are large
-            if upload_input_as_table or _offline_query_inputs_should_be_uploaded(input) or num_shards:
-                with ThreadPoolExecutor(thread_name_prefix="offline_query_upload_input") as upload_input_executor:
-                    query_input = self._upload_offline_query_input(
-                        multi_input,
-                        context=context,
-                        branch=branch,
-                        executor=upload_input_executor,
-                        num_shards=num_shards,
-                    )
-            elif run_asynchronously:
-                query_input = tuple(_to_offline_query_input(x, t) for x, t in multi_input)
+        # Set query_input
+        if input is not None:
+            # Set query_input from input
+            if isinstance(input, OfflineQueryInputUri):
+                query_input = input
+            elif isinstance(input, str):
+                query_input = OfflineQueryInputUri(
+                    parquet_uri=input,
+                    start_row=None,
+                    end_row=None,
+                )
             else:
-                assert len(multi_input) == 1, "We should default to running asynchronously if inputs is partitioned"
-                query_input = _to_offline_query_input(*multi_input[0])
+                # by this point, should be
+                # Union[QueryInput, List[QueryInput], Tuple[QueryInput, ...]]
+                if isinstance(input, (list, tuple)):
+                    input_times_tuple: Sequence[QueryInputTime] = (
+                        [None] * len(input)
+                        if input_times is None
+                        else [input_times for _ in input]
+                        if isinstance(input_times, datetime)
+                        else input_times
+                    )
+                    run_asynchronously = True
+                    multi_input = list(zip(input, input_times_tuple))
+                else:
+                    # Just a QueryInput
+                    multi_input = [(input, cast(None, input_times))]
+
+                # defaulting to uploading input as table if inputs are large
+                if upload_input_as_table or _offline_query_inputs_should_be_uploaded(input) or num_shards:
+                    with ThreadPoolExecutor(thread_name_prefix="offline_query_upload_input") as upload_input_executor:
+                        query_input = self._upload_offline_query_input(
+                            multi_input,
+                            context=context,
+                            branch=branch,
+                            executor=upload_input_executor,
+                            num_shards=num_shards,
+                        )
+                elif run_asynchronously:
+                    query_input = tuple(_to_offline_query_input(x, t) for x, t in multi_input)
+                else:
+                    assert len(multi_input) == 1, "We should default to running asynchronously if inputs is partitioned"
+                    query_input = _to_offline_query_input(*multi_input[0])
+        elif input_sql is not None:
+            query_input = OfflineQueryInputSql(input_sql=input_sql)
+        else:
+            query_input = None
 
         response = self._create_dataset_job(
             optional_output=optional_output_root_fqns,
@@ -3450,6 +3470,7 @@ https://docs.chalk.ai/cli/apply
             Optional[OfflineQueryInput],
             UploadedParquetShardedOfflineQueryInput,
             OfflineQueryInputUri,
+            OfflineQueryInputSql,
         ],
         max_samples: Optional[int],
         dataset_name: Optional[str],
@@ -5212,3 +5233,11 @@ https://docs.chalk.ai/cli/apply
         client_grpc.follow_model_training_job(operation_id=task_response.task_id)
 
         return CreateModelTrainingJobResponse(success=True)
+
+
+def _check_exclusive_options(options: dict[str, Any | None]):
+    filled_options = {k: v for k, v in options.items() if v is not None}
+    if len(filled_options) > 1:
+        raise ValueError(
+            f"Only one of the options: {', '.join(filled_options.keys())} can be specified (they are mutually exclusive options)."
+        )

{chalkpy-2.93.0 → chalkpy-2.93.2}/chalk/client/models.py

@@ -460,6 +460,15 @@ class OfflineQueryInput(BaseModel):
     values: List[List[Any]]  # Values should be of type TJSON
 
 
+class OfflineQueryInputSql(BaseModel):
+    """Input to an offline query specified as a ChalkSQL query instead
+    of literal data.
+
+    Alternative to OfflineQueryInput or OfflineQueryInputUri."""
+
+    input_sql: str
+
+
 class OnlineQueryRequest(BaseModel):
     inputs: Mapping[str, Any]  # Values should be of type TJSON
     outputs: List[str]
@@ -838,6 +847,7 @@ class CreateOfflineQueryJobRequest(BaseModel):
         None,
         UploadedParquetShardedOfflineQueryInput,
         OfflineQueryInputUri,
+        OfflineQueryInputSql,
     ] = None
     """Any givens"""
 

{chalkpy-2.93.0 → chalkpy-2.93.2}/chalk/features/_encoding/converter.py

@@ -50,7 +50,6 @@ from chalk.features._encoding.pyarrow import (
     rich_to_pyarrow,
 )
 from chalk.features._encoding.rich import structure_primitive_to_rich, unstructure_rich_to_primitive
-from chalk.features.feature_wrapper import UnresolvedFeature
 from chalk.utils.collections import unwrap_annotated_if_needed, unwrap_optional_and_annotated_if_needed
 from chalk.utils.df_utils import pa_array_to_pl_series
 from chalk.utils.json import JSON, TJSON, is_pyarrow_json_type, pyarrow_json_type
@@ -1235,14 +1234,8 @@ class FeatureConverter(PrimitiveFeatureConverter[_TPrim], Generic[_TPrim, _TRich
         # because it is also used for error handling inside of `from_rich_to_primitive`.
         self._name = name
         if rich_default != ...:
-            # In notebook environments, UnresolvedFeature may be used as a placeholder
-            # for features that can't be resolved due to a stale registry.
-            # Treat these as missing defaults since they're not concrete values.
-            if isinstance(rich_default, UnresolvedFeature):
-                rich_default = ...
-            else:
-                # The missing value strategy doesn't really matter because rich_default is not missing
-                primitive_default = self.from_rich_to_primitive(rich_default, missing_value_strategy="allow")
+            # The missing value strategy doesn't really matter because rich_default is not missing
+            primitive_default = self.from_rich_to_primitive(rich_default, missing_value_strategy="allow")
         super().__init__(
             name, is_nullable=is_nullable, pyarrow_dtype=pyarrow_dtype, primitive_default=primitive_default
         )

chalkpy-2.93.0/chalk/_version.py

@@ -1 +0,0 @@
-__version__ = "2.93.0"