chalkpy 2.97.2__tar.gz → 2.98.0__tar.gz

{chalkpy-2.97.2 → chalkpy-2.98.0}/PKG-INFO

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

{chalkpy-2.97.2 → chalkpy-2.98.0}/chalk/_gen/chalk/server/v1/named_query_pb2.py

@@ -18,7 +18,7 @@ from chalk._gen.chalk.graph.v1 import graph_pb2 as chalk_dot_graph_dot_v1_dot_gr
 
 
 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
-    b'\n!chalk/server/v1/named_query.proto\x12\x0f\x63halk.server.v1\x1a\x1f\x63halk/auth/v1/permissions.proto\x1a\x1a\x63halk/graph/v1/graph.proto"@\n\x19GetAllNamedQueriesRequest\x12#\n\rdeployment_id\x18\x01 \x01(\tR\x0c\x64\x65ploymentId"0\n\x1aGetNamedQueryByNameRequest\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name"^\n\x1bGetNamedQueryByNameResponse\x12?\n\rnamed_queries\x18\x01 \x03(\x0b\x32\x1a.chalk.graph.v1.NamedQueryR\x0cnamedQueries"]\n\x1aGetAllNamedQueriesResponse\x12?\n\rnamed_queries\x18\x01 \x03(\x0b\x32\x1a.chalk.graph.v1.NamedQueryR\x0cnamedQueries"+\n)GetAllNamedQueriesActiveDeploymentRequest"m\n*GetAllNamedQueriesActiveDeploymentResponse\x12?\n\rnamed_queries\x18\x01 \x03(\x0b\x32\x1a.chalk.graph.v1.NamedQueryR\x0cnamedQueries2\xac\x03\n\x11NamedQueryService\x12u\n\x12GetAllNamedQueries\x12*.chalk.server.v1.GetAllNamedQueriesRequest\x1a+.chalk.server.v1.GetAllNamedQueriesResponse"\x06\x90\x02\x01\x80}\x0b\x12\xa5\x01\n"GetAllNamedQueriesActiveDeployment\x12:.chalk.server.v1.GetAllNamedQueriesActiveDeploymentRequest\x1a;.chalk.server.v1.GetAllNamedQueriesActiveDeploymentResponse"\x06\x90\x02\x01\x80}\x0b\x12x\n\x13GetNamedQueryByName\x12+.chalk.server.v1.GetNamedQueryByNameRequest\x1a,.chalk.server.v1.GetNamedQueryByNameResponse"\x06\x90\x02\x01\x80}\x0b\x42\x98\x01\n\x13\x63om.chalk.server.v1B\x0fNamedQueryProtoP\x01Z\x12server/v1;serverv1\xa2\x02\x03\x43SX\xaa\x02\x0f\x43halk.Server.V1\xca\x02\x0f\x43halk\\Server\\V1\xe2\x02\x1b\x43halk\\Server\\V1\\GPBMetadata\xea\x02\x11\x43halk::Server::V1b\x06proto3'
+    b'\n!chalk/server/v1/named_query.proto\x12\x0f\x63halk.server.v1\x1a\x1f\x63halk/auth/v1/permissions.proto\x1a\x1a\x63halk/graph/v1/graph.proto"@\n\x19GetAllNamedQueriesRequest\x12#\n\rdeployment_id\x18\x01 \x01(\tR\x0c\x64\x65ploymentId"l\n\x1aGetNamedQueryByNameRequest\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12(\n\rquery_version\x18\x02 \x01(\tH\x00R\x0cqueryVersion\x88\x01\x01\x42\x10\n\x0e_query_version"^\n\x1bGetNamedQueryByNameResponse\x12?\n\rnamed_queries\x18\x01 \x03(\x0b\x32\x1a.chalk.graph.v1.NamedQueryR\x0cnamedQueries"]\n\x1aGetAllNamedQueriesResponse\x12?\n\rnamed_queries\x18\x01 \x03(\x0b\x32\x1a.chalk.graph.v1.NamedQueryR\x0cnamedQueries"+\n)GetAllNamedQueriesActiveDeploymentRequest"m\n*GetAllNamedQueriesActiveDeploymentResponse\x12?\n\rnamed_queries\x18\x01 \x03(\x0b\x32\x1a.chalk.graph.v1.NamedQueryR\x0cnamedQueries2\xac\x03\n\x11NamedQueryService\x12u\n\x12GetAllNamedQueries\x12*.chalk.server.v1.GetAllNamedQueriesRequest\x1a+.chalk.server.v1.GetAllNamedQueriesResponse"\x06\x90\x02\x01\x80}\x0b\x12\xa5\x01\n"GetAllNamedQueriesActiveDeployment\x12:.chalk.server.v1.GetAllNamedQueriesActiveDeploymentRequest\x1a;.chalk.server.v1.GetAllNamedQueriesActiveDeploymentResponse"\x06\x90\x02\x01\x80}\x0b\x12x\n\x13GetNamedQueryByName\x12+.chalk.server.v1.GetNamedQueryByNameRequest\x1a,.chalk.server.v1.GetNamedQueryByNameResponse"\x06\x90\x02\x01\x80}\x0b\x42\x98\x01\n\x13\x63om.chalk.server.v1B\x0fNamedQueryProtoP\x01Z\x12server/v1;serverv1\xa2\x02\x03\x43SX\xaa\x02\x0f\x43halk.Server.V1\xca\x02\x0f\x43halk\\Server\\V1\xe2\x02\x1b\x43halk\\Server\\V1\\GPBMetadata\xea\x02\x11\x43halk::Server::V1b\x06proto3'
 )
 
 _globals = globals()
@@ -40,15 +40,15 @@ if _descriptor._USE_C_DESCRIPTORS == False:
     _globals["_GETALLNAMEDQUERIESREQUEST"]._serialized_start = 115
     _globals["_GETALLNAMEDQUERIESREQUEST"]._serialized_end = 179
     _globals["_GETNAMEDQUERYBYNAMEREQUEST"]._serialized_start = 181
-    _globals["_GETNAMEDQUERYBYNAMEREQUEST"]._serialized_end = 229
-    _globals["_GETNAMEDQUERYBYNAMERESPONSE"]._serialized_start = 231
-    _globals["_GETNAMEDQUERYBYNAMERESPONSE"]._serialized_end = 325
-    _globals["_GETALLNAMEDQUERIESRESPONSE"]._serialized_start = 327
-    _globals["_GETALLNAMEDQUERIESRESPONSE"]._serialized_end = 420
-    _globals["_GETALLNAMEDQUERIESACTIVEDEPLOYMENTREQUEST"]._serialized_start = 422
-    _globals["_GETALLNAMEDQUERIESACTIVEDEPLOYMENTREQUEST"]._serialized_end = 465
-    _globals["_GETALLNAMEDQUERIESACTIVEDEPLOYMENTRESPONSE"]._serialized_start = 467
-    _globals["_GETALLNAMEDQUERIESACTIVEDEPLOYMENTRESPONSE"]._serialized_end = 576
-    _globals["_NAMEDQUERYSERVICE"]._serialized_start = 579
-    _globals["_NAMEDQUERYSERVICE"]._serialized_end = 1007
+    _globals["_GETNAMEDQUERYBYNAMEREQUEST"]._serialized_end = 289
+    _globals["_GETNAMEDQUERYBYNAMERESPONSE"]._serialized_start = 291
+    _globals["_GETNAMEDQUERYBYNAMERESPONSE"]._serialized_end = 385
+    _globals["_GETALLNAMEDQUERIESRESPONSE"]._serialized_start = 387
+    _globals["_GETALLNAMEDQUERIESRESPONSE"]._serialized_end = 480
+    _globals["_GETALLNAMEDQUERIESACTIVEDEPLOYMENTREQUEST"]._serialized_start = 482
+    _globals["_GETALLNAMEDQUERIESACTIVEDEPLOYMENTREQUEST"]._serialized_end = 525
+    _globals["_GETALLNAMEDQUERIESACTIVEDEPLOYMENTRESPONSE"]._serialized_start = 527
+    _globals["_GETALLNAMEDQUERIESACTIVEDEPLOYMENTRESPONSE"]._serialized_end = 636
+    _globals["_NAMEDQUERYSERVICE"]._serialized_start = 639
+    _globals["_NAMEDQUERYSERVICE"]._serialized_end = 1067
 # @@protoc_insertion_point(module_scope)

{chalkpy-2.97.2 → chalkpy-2.98.0}/chalk/_gen/chalk/server/v1/named_query_pb2.pyi

@@ -20,10 +20,12 @@ class GetAllNamedQueriesRequest(_message.Message):
     def __init__(self, deployment_id: _Optional[str] = ...) -> None: ...
 
 class GetNamedQueryByNameRequest(_message.Message):
-    __slots__ = ("name",)
+    __slots__ = ("name", "query_version")
     NAME_FIELD_NUMBER: _ClassVar[int]
+    QUERY_VERSION_FIELD_NUMBER: _ClassVar[int]
     name: str
-    def __init__(self, name: _Optional[str] = ...) -> None: ...
+    query_version: str
+    def __init__(self, name: _Optional[str] = ..., query_version: _Optional[str] = ...) -> None: ...
 
 class GetNamedQueryByNameResponse(_message.Message):
     __slots__ = ("named_queries",)

chalkpy-2.98.0/chalk/_version.py

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

{chalkpy-2.97.2 → chalkpy-2.98.0}/chalk/client/client.py

@@ -33,6 +33,7 @@ from chalk.client.models import (
     GetRegisteredModelResponse,
     GetRegisteredModelVersionResponse,
     ManualTriggerScheduledQueryResponse,
+    NamedQueryMetadata,
     OfflineQueryDeadlineOptions,
     OfflineQueryInputUri,
     OnlineQuery,
@@ -1169,6 +1170,36 @@ class ChalkClient:
         """
         ...
 
+    def get_named_query_metadata(
+        self,
+        name: str,
+        query_version: str | None = None,
+    ) -> List[NamedQueryMetadata]:
+        """
+        Get the metadata associated with named queries.
+
+        Parameters
+        ----------
+        name
+            The name of the named query.
+        query_version
+            The query version of the named query. Returns all versions of the named query by default.
+
+        Returns
+        -------
+        list[ScheduledQueryRun]
+            A response message containing the list of metadata of named queries.
+
+        Examples
+        --------
+        >>> from chalk.client import ChalkClient
+        >>> ChalkClient().get_named_query_metadata(
+        ...     name="my_named_query",
+        ...     query_version="1.1.0",
+        ... )
+        """
+        ...
+
     def prompt_evaluation(
         self,
         prompts: list[Prompt | str],

{chalkpy-2.97.2 → chalkpy-2.98.0}/chalk/client/client_grpc.py

@@ -74,6 +74,8 @@ from chalk._gen.chalk.server.v1.model_registry_pb2 import (
     GetModelVersionResponse,
 )
 from chalk._gen.chalk.server.v1.model_registry_pb2_grpc import ModelRegistryServiceStub
+from chalk._gen.chalk.server.v1.named_query_pb2 import GetNamedQueryByNameRequest
+from chalk._gen.chalk.server.v1.named_query_pb2_grpc import NamedQueryServiceStub
 from chalk._gen.chalk.server.v1.offline_queries_pb2_grpc import OfflineQueryMetadataServiceStub
 from chalk._gen.chalk.server.v1.scheduled_query_pb2_grpc import ScheduledQueryServiceStub
 from chalk._gen.chalk.server.v1.scheduled_query_run_pb2 import GetScheduledQueryRunsRequest
@@ -102,6 +104,7 @@ from chalk.client.models import (
 from chalk.client.models import ManualTriggerScheduledQueryResponse as ManualTriggerScheduledQueryResponseDataclass
 from chalk.client.models import (
     ModelUploadUrlResponse,
+    NamedQueryMetadata,
     OnlineQuery,
     OnlineQueryResponse,
     RegisterModelArtifactResponse,
@@ -310,6 +313,14 @@ class StubProvider:
             )
         return ScheduledQueryServiceStub(self._server_channel)
 
+    @cached_property
+    def named_query_stub(self) -> NamedQueryServiceStub:
+        if self._server_channel is None:
+            raise ValueError(
+                "The GRPC engine service is not available. If you would like to set up a GRPC service, please contact Chalk."
+            )
+        return NamedQueryServiceStub(self._server_channel)
+
     @cached_property
     def sql_stub(self) -> SqlServiceStub:
         if self._engine_channel is None:
@@ -568,6 +579,9 @@ class StubRefresher:
     def call_scheduled_query_run_stub(self, fn: Callable[[ScheduledQueryServiceStub], T]) -> T:
         return self._retry_callable(fn, lambda: self._stub.scheduled_query_run_stub)
 
+    def call_get_named_query_metadata(self, fn: Callable[[NamedQueryServiceStub], T]) -> T:
+        return self._retry_callable(fn, lambda: self._stub.named_query_stub)
+
     def call_sql_stub(self, fn: Callable[[SqlServiceStub], T]) -> T:
         return self._retry_callable(fn, lambda: self._stub.sql_stub)
 
@@ -1376,6 +1390,45 @@ class ChalkGRPCClient:
         )
         return [ScheduledQueryRun.from_proto(run) for run in proto_resp.runs]
 
+    def get_named_query_metadata(
+        self,
+        name: str,
+        query_version: str | None = None,
+    ) -> List[NamedQueryMetadata]:
+        """
+        Get the metadata associated with named queries.
+
+        Parameters
+        ----------
+        name
+            The name of the named query.
+        query_version
+            The query version of the named query. Returns all versions of the named query by default.
+
+        Returns
+        -------
+        list[ScheduledQueryRun]
+            A response message containing the list of metadata of named queries.
+
+        Examples
+        --------
+        >>> from chalk.client import ChalkClient
+        >>> ChalkClient().get_named_query_metadata(
+        ...     name="my_named_query",
+        ...     query_version="1.1.0",
+        ... )
+        """
+        proto_resp = self._stub_refresher.call_get_named_query_metadata(
+            lambda x: x.GetNamedQueryByName(
+                request=GetNamedQueryByNameRequest(
+                    name=name,
+                    query_version=query_version,
+                )
+            )
+        )
+
+        return [NamedQueryMetadata.from_proto(nq) for nq in proto_resp.named_queries]
+
     def get_graph(self, deployment: DeploymentId | None = None) -> Graph:
         """Get the graph for a given deployment.
 

{chalkpy-2.97.2 → chalkpy-2.98.0}/chalk/client/client_impl.py

@@ -102,6 +102,7 @@ from chalk.client.models import (
     ManualTriggerScheduledQueryResponse,
     MultiUploadFeaturesRequest,
     MultiUploadFeaturesResponse,
+    NamedQueryMetadata,
     OfflineQueryContext,
     OfflineQueryDeadlineOptions,
     OfflineQueryInput,
@@ -1032,6 +1033,10 @@ class ChalkAPIClientImpl(ChalkClient):
         self._branch: str | None = branch
         self._skip_token_cache: bool = _skip_cache
         self._api_server: str | None = api_server
+        self._env_id_to_engine_url_map: Mapping[str, str] | None = None
+        self._env_id_to_env_name_map: Mapping[str, str] | None = None
+        self._env_name_to_env_id_map: Mapping[str, str] | None = None
+        self._access_token: str | None = None
 
         self._default_headers = {
             "Accept": "application/json",
@@ -1042,7 +1047,7 @@ class ChalkAPIClientImpl(ChalkClient):
         if additional_headers:
             self._default_headers.update(additional_headers)
 
-        self._primary_environment = environment
+        self._primary_environment: EnvironmentId | None = environment
 
         self.__class__.latest_client = self
         if notebook.is_notebook():
@@ -1115,11 +1120,16 @@ class ChalkAPIClientImpl(ChalkClient):
             creds = ExchangeCredentialsResponse(**response_json)
         except ValidationError:
             raise HTTPError(response=resp)
+        self._access_token = creds.access_token
         self._default_headers["Authorization"] = f"Bearer {creds.access_token}"
         # FIXME: We should NOT be using the X-Chalk-Client-Id for anything, as it is NOT authenticated
         self._default_headers["X-Chalk-Client-Id"] = self._client_id
         if self._primary_environment is None:
             self._primary_environment = creds.primary_environment
+        self._env_id_to_engine_url_map = creds.engines
+        self._env_id_to_env_name_map = creds.environment_id_to_name
+        if self._env_id_to_env_name_map is not None:
+            self._env_name_to_env_id_map = {v: k for k, v in self._env_id_to_env_name_map.items()}
 
     def _get_headers(
         self,
@@ -1382,6 +1392,48 @@ https://docs.chalk.ai/docs/debugging-queries#resolver-replay
             method=method, headers=headers, url=url, json=json_body, data=data, timeout=timeout_value
         )
 
+    def _get_engine_host(self, environment_override: Optional[str]) -> str | None:
+        """
+        Returns the host to use for data-plane requests to the engine. May fall back to
+        the metadata plane api server host if no engine host can be determined.
+        :param environment_override: Optional user-provided environment name or id.
+        :return: Host for direct engine (data-plane) requests
+        """
+
+        # always respect user-provided query_server override
+        if self._query_server is not None:
+            return self._query_server
+
+        # if we have no environment information, we likely have not done creds exchange yet.
+        # there's no way to determine an engine host here, so just fall back to api server
+        env_id_or_name: str | None = environment_override or self._primary_environment
+        if env_id_or_name is None:
+            return self._api_server
+
+        # get the correct engine url given a valid env id or env name
+        if self._env_id_to_engine_url_map is not None:
+            if env_id_or_name in self._env_id_to_engine_url_map:
+                return self._env_id_to_engine_url_map[env_id_or_name]
+            elif self._env_name_to_env_id_map is not None and env_id_or_name in self._env_name_to_env_id_map:
+                env_id = self._env_name_to_env_id_map[env_id_or_name]
+                return self._env_id_to_engine_url_map.get(env_id, self._api_server)
+
+        # env name or id is invalid, or we failed to auth, so fall back to api server
+        return self._api_server
+
+    def _get_request_host(self, metadata_request: bool, environment_override: Optional[str]) -> str | None:
+        """
+        Returns the hostname to use for any requests made by the Chalk Client, whether they are
+        metadata-plane-only requests or data-plane requests (to the engine).
+        :param metadata_request: Is this a metadata-plane-only request? If so, we always use the API server.
+        :param environment_override: Optional user-provided environment name or id.
+        :return: Host to use for any request made by the Chalk Client
+        """
+        if metadata_request:
+            return self._api_server
+        else:
+            return self._get_engine_host(environment_override)
+
     def _request(
         self,
         method: str,
@@ -1398,25 +1450,20 @@ https://docs.chalk.ai/docs/debugging-queries#resolver-replay
         timeout: float | None | ellipsis = ...,
         connect_timeout: float | None | ellipsis = ...,
     ) -> T | requests.Response:
+        # If we don't have an access token, we cannot make a request.
+        # Always fetch an access token if we do not have one before making a request.
+        # If we fetched an access token during this call and we get 401/403 on this request,
+        # then do not retry the credential exchange again.
         allow_credential_exchange: bool = True
-
-        if metadata_request or self._query_server is None:
-            host = self._api_server
-        else:
-            host = self._query_server
-
-        if host is None:
-            # We definitively need to exchange credentials to get a host
+        if self._access_token is None:
             self._exchange_credentials()
             allow_credential_exchange = False
 
-            # After exchanging credentials, the api server is never none
-            assert self._api_server is not None
+        host = self._get_request_host(metadata_request, environment_override)
 
-            if metadata_request or self._query_server is None:
-                host = self._api_server
-            else:
-                host = self._query_server
+        # After exchanging credentials, the api server is never null, and the request host
+        # helper function falls back to the api server if it cannot determine an engine url
+        assert host is not None, "After credential exchange, the request host must be non-null"
 
         r = self._do_request_inner(
             method=method,
@@ -1437,14 +1484,11 @@ https://docs.chalk.ai/docs/debugging-queries#resolver-replay
             # It is possible that credentials expired, or that we changed permissions since we last
             # got a token. Exchange them and try again
             self._exchange_credentials()
+            host = self._get_request_host(metadata_request, environment_override)
 
-            # After exchanging credentials, the api server is never null
-            assert self._api_server is not None
-
-            if metadata_request or self._query_server is None:
-                host = self._api_server
-            else:
-                host = self._query_server
+            # After exchanging credentials, the api server is never null, and the request host
+            # helper function falls back to the api server if it cannot determine an engine url
+            assert host is not None, "After credential exchange, the request host must be non-null"
 
             r = self._do_request_inner(
                 method=method,
@@ -2519,6 +2563,50 @@ https://docs.chalk.ai/cli/apply
             limit=limit,
         )
 
+    def get_named_query_metadata(
+        self,
+        name: str,
+        query_version: str | None = None,
+    ) -> List[NamedQueryMetadata]:
+        """
+        Get the metadata associated with named queries.
+
+        Parameters
+        ----------
+        name
+            The name of the named query.
+        query_version
+            The query version of the named query. Returns all versions of the named query by default.
+
+        Returns
+        -------
+        list[ScheduledQueryRun]
+            A response message containing the list of metadata of named queries.
+
+        Examples
+        --------
+        >>> from chalk.client import ChalkClient
+        >>> ChalkClient().get_named_query_metadata(
+        ...     name="my_named_query",
+        ...     query_version="1.1.0",
+        ... )
+        """
+        from chalk.client.client_grpc import ChalkGRPCClient
+
+        client_grpc = ChalkGRPCClient(
+            client_id=self._client_id,
+            client_secret=self._client_secret,
+            environment=self._primary_environment,
+            api_server=self._api_server,
+        )
+
+        resp = client_grpc.get_named_query_metadata(
+            name=name,
+            query_version=query_version,
+        )
+
+        return resp
+
     def prompt_evaluation(
         self,
         prompts: list[Prompt | str],
@@ -3942,9 +4030,8 @@ https://docs.chalk.ai/cli/apply
             environment_override=context.environment,
             preview_deployment_id=preview_deployment_id,
             branch=branch,
-            # If using multiple computers, then we must route through the metadata server
-            # So we can actually spin up multiple pods
-            metadata_request=request.use_multiple_computers,
+            # all offline query requests should be routed through api server
+            metadata_request=True,
         )
         return response
 
@@ -4020,19 +4107,6 @@ https://docs.chalk.ai/cli/apply
             branch=None,
         )
 
-    def _get_query_inputs(
-        self, job_id: uuid.UUID, environment: Optional[EnvironmentId], branch: Optional[BranchId]
-    ) -> GetOfflineQueryJobResponse:
-        return self._request(
-            method="GET",
-            uri=f"/v2/offline_query_inputs/{job_id}",
-            response=GetOfflineQueryJobResponse,
-            environment_override=environment,
-            json=None,
-            preview_deployment_id=None,
-            branch=branch,
-        )
-
     def _get_dataset_from_name_or_id(
         self,
         *,

{chalkpy-2.97.2 → chalkpy-2.98.0}/chalk/client/models.py

@@ -454,6 +454,8 @@ class ExchangeCredentialsResponse(BaseModel):
     api_server: str
     primary_environment: Optional[str] = None
     engines: Optional[Mapping[str, str]] = None
+    grpc_engines: Optional[Mapping[str, str]] = None
+    environment_id_to_name: Optional[Mapping[str, str]] = None
 
 
 class OfflineQueryInput(BaseModel):
@@ -1053,6 +1055,53 @@ class CreateOfflineQueryJobResponse(BaseModel):
     errors: Optional[List[ChalkError]] = None
 
 
+@dataclasses.dataclass
+class NamedQueryMetadata:
+    """Metadata for a named query returned from the API."""
+
+    name: str
+    input: List[str]
+    output: List[str]
+    query_version: Optional[str] = None
+    tags: Optional[List[str]] = None
+    description: Optional[str] = None
+    owner: Optional[str] = None
+    meta: Optional[Dict[str, str]] = None
+    staleness: Optional[Dict[str, timedelta]] = None
+    planner_options: Optional[Dict[str, str]] = None
+    additional_logged_features: Optional[List[str]] = None
+    valid_plan_not_required: Optional[bool] = None
+
+    @staticmethod
+    def from_proto(proto_nq: Any) -> "NamedQueryMetadata":
+        """Convert a proto NamedQuery to the dataclass version."""
+        # Convert proto Duration to timedelta
+        staleness = None
+        if proto_nq.staleness:
+            staleness = {
+                k: timedelta(seconds=v.seconds, microseconds=v.nanos / 1000) for k, v in proto_nq.staleness.items()
+            }
+
+        return NamedQueryMetadata(
+            name=proto_nq.name,
+            query_version=proto_nq.query_version if proto_nq.HasField("query_version") else None,
+            input=list(proto_nq.input),
+            output=list(proto_nq.output),
+            tags=list(proto_nq.tags) if proto_nq.tags else None,
+            description=proto_nq.description if proto_nq.HasField("description") else None,
+            owner=proto_nq.owner if proto_nq.HasField("owner") else None,
+            meta=dict(proto_nq.meta) if proto_nq.meta else None,
+            staleness=staleness,
+            planner_options=dict(proto_nq.planner_options) if proto_nq.planner_options else None,
+            additional_logged_features=list(proto_nq.additional_logged_features)
+            if proto_nq.additional_logged_features
+            else None,
+            valid_plan_not_required=proto_nq.valid_plan_not_required
+            if proto_nq.HasField("valid_plan_not_required")
+            else None,
+        )
+
+
 class CreateBranchResponse(BaseModel):
     branch_already_exists: bool
     errors: Optional[List[ChalkError]] = None

{chalkpy-2.97.2 → chalkpy-2.98.0}/chalk/features/feature_set_decorator.py

@@ -1330,12 +1330,15 @@ def _process_class(
                     error_builder=error_builder,
                 )
 
-                # copy over expressions for default version
+                # copy over expressions and metadata for default version
                 if i == f.version.default:
                     if f.underscore_expression is None and f_i.underscore_expression is not None:
                         f.underscore_expression = f_i.underscore_expression
                     if f.offline_underscore_expression is None and f_i.offline_underscore_expression is not None:
                         f.offline_underscore_expression = f_i.offline_underscore_expression
+                    # Copy description from the explicitly defined default version
+                    if f.description is None and f_i.description is not None:
+                        f.description = f_i.description
 
                 f.version.reference[i] = f_i
                 # The default feature already exists.

chalkpy-2.97.2/chalk/_version.py

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