clarifai 11.7.5rc1__tar.gz → 11.8.0__tar.gz

{clarifai-11.7.5rc1/clarifai.egg-info → clarifai-11.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.7.5rc1
+Version: 11.8.0
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
 Author-email: support@clarifai.com

clarifai-11.8.0/clarifai/__init__.py

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

{clarifai-11.7.5rc1 → clarifai-11.8.0}/clarifai/client/user.py

@@ -533,178 +533,6 @@ class User(Lister, BaseClient):
         ]
         return f"Clarifai User Details: \n{', '.join(attribute_strings)}\n"
 
-    def get_secret(self, secret_id: str) -> dict:
-        """Returns a secret object if exists.
-
-        Args:
-            secret_id (str): The secret ID to interact with
-
-        Returns:
-            Dict: A dictionary containing information about the existing secret ID.
-
-        Example:
-            >>> from clarifai.client.user import User
-            >>> client = User(user_id="user_id")
-            >>> secret_info = client.get_secret(secret_id="secret_id")
-        """
-        request = service_pb2.GetSecretRequest(user_app_id=self.user_app_id, id=secret_id)
-        response = self._grpc_request(self.STUB.GetSecret, request)
-        if response.status.code != status_code_pb2.SUCCESS:
-            raise Exception(
-                f"""Error getting secret, are you sure this is a valid secret id {secret_id} at the user_id
-          {self.user_app_id.user_id}.
-          Error: {response.status.description}"""
-            )
-
-        dict_response = MessageToDict(response, preserving_proto_field_name=True)
-        kwargs = self.process_response_keys(dict_response["secret"], "secret")
-
-        return dict(auth=self.auth_helper, **kwargs)
-
-    def list_secrets(
-        self, page_no: int = None, per_page: int = None
-    ) -> Generator[dict, None, None]:
-        """List all secrets for the user
-
-        Args:
-            page_no (int): The page number to list.
-            per_page (int): The number of items per page.
-
-        Yields:
-            Dict: Dictionaries containing information about the secrets.
-
-        Example:
-            >>> from clarifai.client.user import User
-            >>> client = User(user_id="user_id")
-            >>> all_secrets = list(client.list_secrets())
-
-        Note:
-            Defaults to 16 per page if page_no is specified and per_page is not specified.
-            If both page_no and per_page are None, then lists all the resources.
-        """
-        request_data = dict(user_app_id=self.user_app_id)
-        all_secrets_info = self.list_pages_generator(
-            self.STUB.ListSecrets,
-            service_pb2.ListSecretsRequest,
-            request_data,
-            per_page=per_page,
-            page_no=page_no,
-        )
-        for secret_info in all_secrets_info:
-            yield dict(auth=self.auth_helper, **secret_info)
-
-    def create_secrets(self, secrets: List[Dict[str, Any]]) -> List[dict]:
-        """Creates secrets for the user.
-
-        Args:
-            secrets (List[Dict[str, Any]]): List of secret configurations to create.
-                Each secret dict can contain:
-                - id (str): The name/ID of the secret (required)
-                - value (str): The secret value (required)
-                - description (str): Optional description of the secret
-                - expires_at (str): Optional expiration timestamp
-
-        Returns:
-            List[Dict]: List of dictionaries containing information about the created secrets.
-
-        Example:
-            >>> from clarifai.client.user import User
-            >>> client = User(user_id="user_id")
-            >>> secrets = [{"id": "secret1", "value": "secret_value", "description": "My Secret"}]
-            >>> created_secrets = client.create_secrets(secrets)
-        """
-        assert isinstance(secrets, list), "secrets param should be a list"
-
-        # Convert dict secrets to protobuf Secret objects
-        secret_objects = []
-        for secret_config in secrets:
-            secret_objects.append(resources_pb2.Secret(**secret_config))
-
-        request = service_pb2.PostSecretsRequest(
-            user_app_id=self.user_app_id, secrets=secret_objects
-        )
-        response = self._grpc_request(self.STUB.PostSecrets, request)
-        if response.status.code != status_code_pb2.SUCCESS:
-            raise Exception(response.status)
-
-        self.logger.info(f"Secrets created successfully:\n{response.status}")
-
-        # Convert response to list of dictionaries
-        dict_response = MessageToDict(response, preserving_proto_field_name=True)
-        created_secrets = []
-        for secret in dict_response.get("secrets", []):
-            kwargs = self.process_response_keys(secret, "secret")
-            created_secrets.append(dict(auth=self.auth_helper, **kwargs))
-
-        return created_secrets
-
-    def patch_secrets(
-        self, secrets: List[Dict[str, Any]], action: str = 'overwrite'
-    ) -> List[dict]:
-        """Patches secrets for the user.
-
-        Args:
-            secrets (List[Dict[str, Any]]): List of secret configurations to patch.
-                Each secret dict should contain:
-                - id (str): The name/ID of the secret to patch (required)
-                - value (str): Optional new secret value
-                - description (str): Optional new description
-                - expires_at (str): Optional new expiration timestamp
-            action (str): The action to perform on the secrets (overwrite/remove).
-
-        Returns:
-            List[Dict]: List of dictionaries containing information about the patched secrets.
-
-        Example:
-            >>> from clarifai.client.user import User
-            >>> client = User(user_id="user_id")
-            >>> secrets = [{"id": "secret1", "description": "Updated Secret Description"}]
-            >>> patched_secrets = client.patch_secrets(secrets, action="overwrite")
-        """
-        assert isinstance(secrets, list), "secrets param should be a list"
-
-        # Convert dict secrets to protobuf Secret objects
-        secret_objects = []
-        for secret_config in secrets:
-            secret_objects.append(resources_pb2.Secret(**secret_config))
-
-        request = service_pb2.PatchSecretsRequest(
-            user_app_id=self.user_app_id, secret=secret_objects, action=action
-        )
-        response = self._grpc_request(self.STUB.PatchSecrets, request)
-        if response.status.code != status_code_pb2.SUCCESS:
-            raise Exception(response.status)
-
-        self.logger.info(f"Secrets patched successfully:\n{response.status}")
-
-        # Convert response to list of dictionaries
-        dict_response = MessageToDict(response, preserving_proto_field_name=True)
-        patched_secrets = []
-        for secret in dict_response.get("secrets", []):
-            kwargs = self.process_response_keys(secret, "secret")
-            patched_secrets.append(dict(auth=self.auth_helper, **kwargs))
-
-        return patched_secrets
-
-    def delete_secrets(self, secret_ids: List[str]) -> None:
-        """Deletes a list of secrets for the user.
-
-        Args:
-            secret_ids (List[str]): The secret IDs of the user to delete.
-
-        Example:
-            >>> from clarifai.client.user import User
-            >>> client = User(user_id="user_id")
-            >>> client.delete_secrets(secret_ids=["secret_id1", "secret_id2"])
-        """
-        assert isinstance(secret_ids, list), "secret_ids param should be a list"
-
-        request = service_pb2.DeleteSecretsRequest(user_app_id=self.user_app_id, ids=secret_ids)
-        response = self._grpc_request(self.STUB.DeleteSecrets, request)
-        if response.status.code != status_code_pb2.SUCCESS:
-            raise Exception(response.status)
-        self.logger.info("\nSecrets Deleted\n%s", response.status)
-
     def list_models(
         self,
         user_id: str = None,

{clarifai-11.7.5rc1 → clarifai-11.8.0}/clarifai/runners/models/model_builder.py

@@ -102,7 +102,6 @@ class ModelBuilder:
         self.folder = self._validate_folder(folder)
         self.config = self._load_config(os.path.join(self.folder, 'config.yaml'))
         self._validate_config()
-        self._validate_config_secrets()
         self._validate_stream_options()
         self.model_proto = self._get_model_proto()
         self.model_id = self.model_proto.id
@@ -466,115 +465,6 @@ class ModelBuilder:
                     "2) set_output_context"
                 )
 
-    def _validate_config_secrets(self):
-        """
-        Validate the secrets section in the config file.
-        """
-        if "secrets" not in self.config:
-            return
-
-        secrets = self.config.get("secrets", [])
-        if not isinstance(secrets, list):
-            raise ValueError("The 'secrets' field must be an array.")
-
-        for i, secret in enumerate(secrets):
-            if not isinstance(secret, dict):
-                raise ValueError(f"Secret at index {i} must be a dictionary.")
-
-            # Validate required fields
-            if "id" not in secret or not secret["id"]:
-                raise ValueError(f"Secret at index {i} must have a non-empty 'id' field.")
-
-            if "type" not in secret or not secret["type"]:
-                secret["type"] = "env"
-
-            if "env_var" not in secret or not secret["env_var"]:
-                raise ValueError(f"Secret at index {i} must have a non-empty 'env_var' field.")
-            # Validate secret type
-            if secret["type"] != "env":
-                raise ValueError(
-                    f"Secret at index {i} has invalid type '{secret['type']}'. Must be 'env'."
-                )
-
-        logger.info(f"Validated {len(secrets)} secrets in config file.")
-
-    def _process_secrets(self):
-        """
-        Process secrets from config file and create/validate them using the User client.
-        Returns the processed secrets array for inclusion in ModelVersion.OutputInfo.Params.
-        """
-        if "secrets" not in self.config:
-            return []
-
-        secrets = self.config.get("secrets", [])
-        if not secrets:
-            return []
-
-        # Get user client for secret operations
-        user = User(
-            user_id=self.config.get('model').get('user_id'),
-            pat=self.client.pat,
-            token=self.client.token,
-            base_url=self.client.base,
-        )
-
-        processed_secrets = []
-        secrets_to_create = []
-
-        for secret in secrets:
-            secret_id = secret["id"]
-            secret_type = secret.get("type", "env")
-            env_var = secret["env_var"]
-            secret_value = secret.get("value")  # Optional for existing secrets
-
-            # Check if secret already exists
-            try:
-                existing_secret = user.get_secret(secret_id)
-                logger.info(f"Secret '{secret_id}' already exists, using existing secret.")
-
-                # Add to processed secrets without the value
-                processed_secret = {
-                    "id": secret_id,
-                    "type": secret_type,
-                    "env_var": env_var,
-                }
-                processed_secrets.append(processed_secret)
-
-            except Exception:
-                # Secret doesn't exist, need to create it
-                if secret_value:
-                    logger.info(f"Secret '{secret_id}' does not exist, will create it.")
-                    secrets_to_create.append(
-                        {
-                            "id": secret_id,
-                            "value": secret_value,
-                            "description": secret.get("description", f"Secret for {env_var}"),
-                        }
-                    )
-
-                    # Add to processed secrets
-                    processed_secret = {
-                        "id": secret_id,
-                        "type": secret_type,
-                        "env_var": env_var,
-                    }
-                    processed_secrets.append(processed_secret)
-                else:
-                    raise ValueError(
-                        f"Secret '{secret_id}' does not exist and no value provided for creation."
-                    )
-
-        # Create new secrets if any
-        if secrets_to_create:
-            try:
-                created_secrets = user.create_secrets(secrets_to_create)
-                logger.info(f"Successfully created {len(created_secrets)} new secrets.")
-            except Exception as e:
-                logger.error(f"Failed to create secrets: {e}")
-                raise
-
-        return processed_secrets
-
     def _is_clarifai_internal(self):
         """
         Check if the current user is a Clarifai internal user based on email domain.
@@ -1368,29 +1258,6 @@ class ModelBuilder:
             metadata_struct.update({'git_registry': git_info})
             model_version_proto.metadata.CopyFrom(metadata_struct)
 
-        # Process and add secrets to output_info.params
-        try:
-            processed_secrets = self._process_secrets()
-            if processed_secrets:
-                # Initialize output_info.params if not already present
-                if not model_version_proto.HasField("output_info"):
-                    model_version_proto.output_info.CopyFrom(resources_pb2.OutputInfo())
-
-                # Initialize params if not already present
-                if not model_version_proto.output_info.HasField("params"):
-                    from google.protobuf.struct_pb2 import Struct
-
-                    model_version_proto.output_info.params.CopyFrom(Struct())
-
-                # Add secrets to params
-                model_version_proto.output_info.params.update({"secrets": processed_secrets})
-                logger.info(
-                    f"Added {len(processed_secrets)} secrets to model version output_info.params"
-                )
-        except Exception as e:
-            logger.error(f"Failed to process secrets: {e}")
-            raise
-
         model_type_id = self.config.get('model').get('model_type_id')
         if model_type_id in CONCEPTS_REQUIRED_MODEL_TYPE:
             if 'concepts' in self.config:

{clarifai-11.7.5rc1 → clarifai-11.8.0}/clarifai/runners/models/model_runner.py

@@ -301,6 +301,27 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
         """Set the model for this runner."""
         self.model = model
 
+    def handle_liveness_probe(self):
+        # if the model has a handle_liveness_probe method, call it to determine liveness
+        # otherwise rely on HealthProbeRequestHandler.is_alive from the protocol
+        if hasattr(self.model, 'handle_liveness_probe'):
+            HealthProbeRequestHandler.is_alive = self.model.handle_liveness_probe()
+        return super().handle_liveness_probe()
+
+    def handle_readiness_probe(self):
+        # if the model has a handle_readiness_probe method, call it to determine readiness
+        # otherwise rely on HealthProbeRequestHandler.is_ready from the protocol
+        if hasattr(self.model, 'handle_readiness_probe'):
+            HealthProbeRequestHandler.is_ready = self.model.handle_readiness_probe()
+        return super().handle_readiness_probe()
+
+    def handle_startup_probe(self):
+        # if the model has a handle_startup_probe method, call it to determine startup
+        # otherwise rely on HealthProbeRequestHandler.is_startup from the protocol
+        if hasattr(self.model, 'handle_startup_probe'):
+            HealthProbeRequestHandler.is_startup = self.model.handle_startup_probe()
+        return super().handle_startup_probe()
+
 
 def pmo_iterator(runner_item_iterator, auth_helper=None):
     for runner_item in runner_item_iterator:

{clarifai-11.7.5rc1 → clarifai-11.8.0}/clarifai/runners/models/openai_class.py

@@ -69,6 +69,24 @@ class OpenAIModelClass(ModelClass):
 
         return completion_args
 
+    def handle_liveness_probe(self) -> bool:
+        """Handle liveness probe by checking if the client can list models."""
+        try:
+            _ = self.client.models.list()
+            return True
+        except Exception as e:
+            logger.error(f"Liveness probe failed: {e}", exc_info=True)
+            return False
+
+    def handle_readiness_probe(self) -> bool:
+        """Handle readiness probe by checking if the client can list models."""
+        try:
+            _ = self.client.models.list()
+            return True
+        except Exception as e:
+            logger.error(f"Readiness probe failed: {e}", exc_info=True)
+            return False
+
     def _set_usage(self, resp):
         if resp.usage and resp.usage.prompt_tokens and resp.usage.completion_tokens:
             self.set_output_context(

{clarifai-11.7.5rc1 → clarifai-11.8.0/clarifai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.7.5rc1
+Version: 11.8.0
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
 Author-email: support@clarifai.com

clarifai-11.8.0/clarifai.egg-info/SOURCES.txt

@@ -0,0 +1,150 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+requirements.txt
+setup.py
+clarifai/__init__.py
+clarifai/cli.py
+clarifai/errors.py
+clarifai/versions.py
+clarifai.egg-info/PKG-INFO
+clarifai.egg-info/SOURCES.txt
+clarifai.egg-info/dependency_links.txt
+clarifai.egg-info/entry_points.txt
+clarifai.egg-info/requires.txt
+clarifai.egg-info/top_level.txt
+clarifai/cli/README.md
+clarifai/cli/__init__.py
+clarifai/cli/__main__.py
+clarifai/cli/base.py
+clarifai/cli/compute_cluster.py
+clarifai/cli/deployment.py
+clarifai/cli/model.py
+clarifai/cli/nodepool.py
+clarifai/cli/pipeline.py
+clarifai/cli/pipeline_step.py
+clarifai/cli/templates/__init__.py
+clarifai/cli/templates/model_templates.py
+clarifai/cli/templates/pipeline_step_templates.py
+clarifai/cli/templates/pipeline_templates.py
+clarifai/client/__init__.py
+clarifai/client/app.py
+clarifai/client/base.py
+clarifai/client/compute_cluster.py
+clarifai/client/dataset.py
+clarifai/client/deployment.py
+clarifai/client/input.py
+clarifai/client/lister.py
+clarifai/client/model.py
+clarifai/client/model_client.py
+clarifai/client/module.py
+clarifai/client/nodepool.py
+clarifai/client/pipeline.py
+clarifai/client/pipeline_step.py
+clarifai/client/runner.py
+clarifai/client/search.py
+clarifai/client/user.py
+clarifai/client/workflow.py
+clarifai/client/auth/__init__.py
+clarifai/client/auth/helper.py
+clarifai/client/auth/register.py
+clarifai/client/auth/stub.py
+clarifai/constants/base.py
+clarifai/constants/dataset.py
+clarifai/constants/input.py
+clarifai/constants/model.py
+clarifai/constants/rag.py
+clarifai/constants/search.py
+clarifai/constants/workflow.py
+clarifai/datasets/__init__.py
+clarifai/datasets/export/__init__.py
+clarifai/datasets/export/inputs_annotations.py
+clarifai/datasets/upload/__init__.py
+clarifai/datasets/upload/base.py
+clarifai/datasets/upload/features.py
+clarifai/datasets/upload/image.py
+clarifai/datasets/upload/multimodal.py
+clarifai/datasets/upload/text.py
+clarifai/datasets/upload/utils.py
+clarifai/datasets/upload/loaders/README.md
+clarifai/datasets/upload/loaders/__init__.py
+clarifai/datasets/upload/loaders/coco_captions.py
+clarifai/datasets/upload/loaders/coco_detection.py
+clarifai/datasets/upload/loaders/imagenet_classification.py
+clarifai/datasets/upload/loaders/xview_detection.py
+clarifai/models/__init__.py
+clarifai/models/api.py
+clarifai/modules/README.md
+clarifai/modules/__init__.py
+clarifai/modules/css.py
+clarifai/modules/pages.py
+clarifai/modules/style.css
+clarifai/rag/__init__.py
+clarifai/rag/rag.py
+clarifai/rag/utils.py
+clarifai/runners/__init__.py
+clarifai/runners/server.py
+clarifai/runners/dockerfile_template/Dockerfile.template
+clarifai/runners/models/__init__.py
+clarifai/runners/models/dummy_openai_model.py
+clarifai/runners/models/mcp_class.py
+clarifai/runners/models/model_builder.py
+clarifai/runners/models/model_class.py
+clarifai/runners/models/model_run_locally.py
+clarifai/runners/models/model_runner.py
+clarifai/runners/models/model_servicer.py
+clarifai/runners/models/openai_class.py
+clarifai/runners/models/visual_classifier_class.py
+clarifai/runners/models/visual_detector_class.py
+clarifai/runners/pipeline_steps/__init__.py
+clarifai/runners/pipeline_steps/pipeline_step_builder.py
+clarifai/runners/pipelines/__init__.py
+clarifai/runners/pipelines/pipeline_builder.py
+clarifai/runners/utils/__init__.py
+clarifai/runners/utils/code_script.py
+clarifai/runners/utils/const.py
+clarifai/runners/utils/data_utils.py
+clarifai/runners/utils/loader.py
+clarifai/runners/utils/method_signatures.py
+clarifai/runners/utils/model_utils.py
+clarifai/runners/utils/openai_convertor.py
+clarifai/runners/utils/pipeline_validation.py
+clarifai/runners/utils/serializers.py
+clarifai/runners/utils/url_fetcher.py
+clarifai/runners/utils/data_types/__init__.py
+clarifai/runners/utils/data_types/data_types.py
+clarifai/schema/search.py
+clarifai/urls/helper.py
+clarifai/utils/__init__.py
+clarifai/utils/cli.py
+clarifai/utils/config.py
+clarifai/utils/constants.py
+clarifai/utils/logging.py
+clarifai/utils/misc.py
+clarifai/utils/model_train.py
+clarifai/utils/protobuf.py
+clarifai/utils/secrets.py
+clarifai/utils/evaluation/__init__.py
+clarifai/utils/evaluation/helpers.py
+clarifai/utils/evaluation/main.py
+clarifai/utils/evaluation/testset_annotation_parser.py
+clarifai/workflows/__init__.py
+clarifai/workflows/export.py
+clarifai/workflows/utils.py
+clarifai/workflows/validate.py
+tests/test_app.py
+tests/test_async_stub.py
+tests/test_auth.py
+tests/test_data_upload.py
+tests/test_eval.py
+tests/test_list_models.py
+tests/test_misc.py
+tests/test_model_predict.py
+tests/test_model_train.py
+tests/test_modules.py
+tests/test_pipeline_client.py
+tests/test_rag.py
+tests/test_search.py
+tests/test_secrets.py
+tests/test_stub.py

clarifai-11.7.5rc1/clarifai/__init__.py

@@ -1 +0,0 @@
-__version__ = "11.7.5rc1"