chalkpy 2.131.1__tar.gz → 2.131.2__tar.gz

{chalkpy-2.131.1 → chalkpy-2.131.2}/PKG-INFO

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

chalkpy-2.131.2/chalk/_version.py

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

{chalkpy-2.131.1 → chalkpy-2.131.2}/chalk/client/client.py

@@ -2907,6 +2907,68 @@ class ChalkClient:
         """
         ...
 
+    def delete_model_namespace(
+        self,
+        name: str,
+    ) -> GetRegisteredModelResponse:
+        """Delete a model namespace from the Chalk model registry.
+
+        This archives the model and all of its versions. **The underlying model
+        artifact data for those versions is permanently deleted from storage**
+        (any artifact not still referenced by another version). A model cannot
+        be deleted while it is referenced by the active deployment or a scaling
+        group.
+
+        Parameters
+        ----------
+        name
+            Name of the model namespace to delete.
+
+        Returns
+        -------
+        GetRegisteredModelResponse
+            The archived model.
+
+        Examples
+        --------
+        >>> from chalk.client import ChalkClient
+        >>> client = ChalkClient()
+        >>> client.delete_model_namespace(name="RiskModel")
+        """
+        ...
+
+    def delete_model_version(
+        self,
+        name: str,
+        version: int,
+    ) -> GetRegisteredModelVersionResponse:
+        """Delete a single model version from the Chalk model registry.
+
+        This archives the given version. **The underlying model artifact data is
+        permanently deleted from storage** (unless the artifact is still
+        referenced by another version). A version cannot be deleted while it is
+        referenced by the active deployment or a scaling group.
+
+        Parameters
+        ----------
+        name
+            Name of the model the version belongs to.
+        version
+            Version number to delete.
+
+        Returns
+        -------
+        GetRegisteredModelVersionResponse
+            The archived model version.
+
+        Examples
+        --------
+        >>> from chalk.client import ChalkClient
+        >>> client = ChalkClient()
+        >>> client.delete_model_version(name="RiskModel", version=1)
+        """
+        ...
+
     def deploy_model_version_to_scaling_group(
         self,
         name: str,

{chalkpy-2.131.1 → chalkpy-2.131.2}/chalk/client/client_grpc.py

@@ -101,6 +101,10 @@ from chalk._gen.chalk.server.v1.model_registry_pb2 import (
     CreateModelVersionFromArtifactResponse,
     CreateModelVersionRequest,
     CreateModelVersionResponse,
+    DeleteModelRequest,
+    DeleteModelResponse,
+    DeleteModelVersionRequest,
+    DeleteModelVersionResponse,
     DownloadModelArtifactRequest,
     DownloadModelArtifactResponse,
     GetModelArtifactUploadUrlsRequest,
@@ -2897,6 +2901,126 @@ class ChalkGRPCClient:
         except grpc.RpcError as e:
             raise RuntimeError(f"Could not register model. {e.details()}")
 
+    def delete_model_namespace(
+        self,
+        name: str,
+    ) -> GetRegisteredModelResponse:
+        """
+        Delete a model namespace (and all of its versions) from the Chalk model registry.
+
+        The underlying model artifact data for those versions is permanently
+        deleted from storage (any artifact not still referenced by another
+        version).
+
+        Parameters
+        ----------
+        name : str
+            Name of the model namespace to delete
+
+        Returns
+        -------
+        GetRegisteredModelResponse
+            The archived model
+
+        Examples
+        --------
+        >>> from chalk.client import ChalkClient
+        >>> client = ChalkClient()
+        >>> client.delete_model_namespace(name="RiskModel")
+        """
+
+        try:
+            resp: DeleteModelResponse = self._stub_refresher.call_model_stub(
+                lambda x: x.DeleteModel(
+                    DeleteModelRequest(
+                        model_name=name,
+                    )
+                )
+            )
+            return GetRegisteredModelResponse(
+                model_id=resp.model.id,
+                model_name=resp.model.model_name,
+                description=resp.model.description,
+                metadata=ModelSerializer.convert_metadata_from_protobuf(resp.model.metadata),
+                created_by=resp.model.created_by,
+                created_at=resp.model.created_at.ToDatetime(),
+                updated_at=resp.model.updated_at.ToDatetime(),
+                archived_at=resp.model.archived_at.ToDatetime(),
+                latest_model_version=resp.model.latest_model_version,
+            )
+        except grpc.RpcError as e:
+            raise RuntimeError(f"Could not delete model. {e.details()}")
+
+    def delete_model_version(
+        self,
+        name: str,
+        version: int,
+    ) -> GetRegisteredModelVersionResponse:
+        """
+        Delete a single model version from the Chalk model registry.
+
+        The underlying model artifact data is permanently deleted from storage
+        (unless the artifact is still referenced by another version).
+
+        Parameters
+        ----------
+        name : str
+            Name of the model the version belongs to
+        version : int
+            Version number to delete
+
+        Returns
+        -------
+        GetRegisteredModelVersionResponse
+            The archived model version
+
+        Examples
+        --------
+        >>> from chalk.client import ChalkClient
+        >>> client = ChalkClient()
+        >>> client.delete_model_version(name="RiskModel", version=1)
+        """
+
+        try:
+            resp: DeleteModelVersionResponse = self._stub_refresher.call_model_stub(
+                lambda x: x.DeleteModelVersion(
+                    DeleteModelVersionRequest(
+                        model_version_key=ModelVersionKey(
+                            model_name=name,
+                            version=version,
+                        )
+                    )
+                )
+            )
+
+            model_artifact = ModelArtifactSpec(
+                model_type=model_type_from_proto(resp.model_version.model_artifact.spec.model_type),
+                model_class=model_class_from_proto(resp.model_version.model_artifact.spec.model_class),
+                model_encoding=model_encoding_from_proto(resp.model_version.model_artifact.spec.model_encoding),
+                model_files=[file.name for file in resp.model_version.model_artifact.spec.model_files],
+                additional_files=[file.name for file in resp.model_version.model_artifact.spec.additional_files],
+                input_schema=ModelSerializer.convert_schema_from_protobuf(
+                    resp.model_version.model_artifact.spec.model_signature.inputs
+                ),
+                output_schema=ModelSerializer.convert_schema_from_protobuf(
+                    resp.model_version.model_artifact.spec.model_signature.outputs
+                ),
+                metadata=ModelSerializer.convert_metadata_from_protobuf(resp.model_version.model_artifact.metadata),
+                input_features=list(resp.model_version.model_artifact.spec.input_features),
+                output_features=list(resp.model_version.model_artifact.spec.output_features),
+                dependencies=list(resp.model_version.model_artifact.spec.python_dependencies),
+            )
+
+            return GetRegisteredModelVersionResponse(
+                model_id=resp.model_version.id,
+                model_name=resp.model_version.model_name,
+                created_by=resp.model_version.created_by,
+                created_at=resp.model_version.created_at.ToDatetime(),
+                model_artifact=model_artifact,
+            )
+        except grpc.RpcError as e:
+            raise RuntimeError(f"Could not delete model version. {e.details()}")
+
     def _get_model_artifact_presigned(self, model_paths: List[str]) -> ModelUploadUrlResponse:
         try:
             resp: GetModelArtifactUploadUrlsResponse = self._stub_refresher.call_model_stub(

{chalkpy-2.131.1 → chalkpy-2.131.2}/chalk/client/client_impl.py

@@ -6188,6 +6188,21 @@ https://docs.chalk.ai/cli/apply
             model_image=model_image,
         )
 
+    def delete_model_namespace(
+        self,
+        name: str,
+        environment: Optional[EnvironmentId] = None,
+    ) -> GetRegisteredModelResponse:
+        return self._get_grpc_client(environment=environment).delete_model_namespace(name=name)
+
+    def delete_model_version(
+        self,
+        name: str,
+        version: int,
+        environment: Optional[EnvironmentId] = None,
+    ) -> GetRegisteredModelVersionResponse:
+        return self._get_grpc_client(environment=environment).delete_model_version(name=name, version=version)
+
     def deploy_model_version_to_scaling_group(
         self,
         name: str,

{chalkpy-2.131.1 → chalkpy-2.131.2}/chalk/utils/tracing.py

@@ -55,14 +55,68 @@ _TRACING_CONFIGURED = Once()
 _logger = get_logger(__name__)
 
 if can_use_otel_trace:
+    import os as _os
+
     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")
 
+    # Skip span allocation when no exporter is configured.
+    _TRACING_ENABLED: bool = _os.environ.get("OTEL_TRACES_SAMPLER") != "always_off" and any(
+        _os.environ.get(var)
+        for var in (
+            "OTEL_EXPORTER_OTLP_ENDPOINT",
+            "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT",
+        )
+    )
+
+    class _NoOpSpan:
+        """Duck-typed no-op Span. Yielded by `safe_trace` when tracing is disabled."""
+
+        __slots__ = ()
+
+        def set_attribute(self, *args: object, **kwargs: object) -> "_NoOpSpan":
+            return self
+
+        def set_attributes(self, *args: object, **kwargs: object) -> "_NoOpSpan":
+            return self
+
+        def set_status(self, *args: object, **kwargs: object) -> "_NoOpSpan":
+            return self
+
+        def add_event(self, *args: object, **kwargs: object) -> "_NoOpSpan":
+            return self
+
+        def record_exception(self, *args: object, **kwargs: object) -> "_NoOpSpan":
+            return self
+
+        def update_name(self, *args: object, **kwargs: object) -> "_NoOpSpan":
+            return self
+
+        def end(self, *args: object, **kwargs: object) -> None:
+            return None
+
+        def is_recording(self) -> bool:
+            return False
+
+        def get_span_context(self):  # noqa: ANN201 — match Span API
+            return otel_trace.INVALID_SPAN_CONTEXT
+
+        def __enter__(self) -> "_NoOpSpan":
+            return self
+
+        def __exit__(self, *exc_info: object) -> None:
+            return None
+
+    _NOOP_SPAN: _NoOpSpan = _NoOpSpan()
+
     @contextlib.contextmanager
     def safe_trace(span_id: str, attributes: Mapping[str, str] | None = None):  # pyright: ignore[reportRedeclaration]
+        if not _TRACING_ENABLED:
+            yield _NOOP_SPAN
+            return
         configure_tracing("chalkpy")
         if attributes is None:
             attributes = {}
@@ -73,16 +127,22 @@ if can_use_otel_trace:
             yield span
 
     def safe_add_metrics(metrics: Mapping[str, Union[int, float]]):  # pyright: ignore[reportRedeclaration]
+        if not _TRACING_ENABLED:
+            return
         configure_tracing("chalkpy")
         current_span = otel_trace.get_current_span()
         current_span.set_attributes(dict(metrics))
 
     def safe_add_tags(tags: Mapping[str, str]):
+        if not _TRACING_ENABLED:
+            return
         configure_tracing("chalkpy")
         current_span = otel_trace.get_current_span()
         current_span.set_attributes(dict(tags))
 
     def safe_current_trace_context() -> otel_trace.SpanContext | None:  # pyright: ignore[reportRedeclaration]
+        if not _TRACING_ENABLED:
+            return None
         configure_tracing("chalkpy")
         return otel_trace.get_current_span().get_span_context()
 

chalkpy-2.131.1/chalk/_version.py

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