clarifai 11.8.3__tar.gz → 11.8.5__tar.gz

{clarifai-11.8.3/clarifai.egg-info → clarifai-11.8.5}/PKG-INFO

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

clarifai-11.8.5/clarifai/__init__.py

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

{clarifai-11.8.3 → clarifai-11.8.5}/clarifai/cli/model.py

@@ -28,6 +28,7 @@ from clarifai.utils.constants import (
     DEFAULT_LOCAL_RUNNER_NODEPOOL_CONFIG,
     DEFAULT_LOCAL_RUNNER_NODEPOOL_ID,
     DEFAULT_OLLAMA_MODEL_REPO_BRANCH,
+    DEFAULT_PYTHON_MODEL_REPO_BRANCH,
     DEFAULT_TOOLKIT_MODEL_REPO,
     DEFAULT_VLLM_MODEL_REPO_BRANCH,
 )
@@ -74,9 +75,11 @@ def model():
 )
 @click.option(
     '--toolkit',
-    type=click.Choice(['ollama', 'huggingface', 'lmstudio', 'vllm'], case_sensitive=False),
+    type=click.Choice(
+        ['ollama', 'huggingface', 'lmstudio', 'vllm', 'python'], case_sensitive=False
+    ),
     required=False,
-    help='Toolkit to use for model initialization. Currently supports "ollama", "huggingface", "lmstudio" and "vllm".',
+    help='Toolkit to use for model initialization. Currently supports "ollama", "huggingface", "lmstudio", "vllm" and "python".',
 )
 @click.option(
     '--model-name',
@@ -95,7 +98,9 @@ def model():
     help='Context length for the Ollama model. Defaults to 8192.',
     required=False,
 )
+@click.pass_context
 def init(
+    ctx,
     model_path,
     model_type_id,
     github_pat,
@@ -124,11 +129,13 @@ def init(
     MODEL_TYPE_ID: Type of model to create. If not specified, defaults to "text-to-text" for text models.\n
     GITHUB_PAT: GitHub Personal Access Token for authentication when cloning private repositories.\n
     GITHUB_URL: GitHub repository URL or "repo" format to clone a repository from. If provided, the entire repository contents will be copied to the target directory instead of using default templates.\n
-    TOOLKIT: Toolkit to use for model initialization. Currently supports "ollama", "huggingface", "lmstudio" and "vllm".\n
+    TOOLKIT: Toolkit to use for model initialization. Currently supports "ollama", "huggingface", "lmstudio", "vllm" and "python".\n
     MODEL_NAME: Model name to configure when using --toolkit. For ollama toolkit, this sets the Ollama model to use (e.g., "llama3.1", "mistral", etc.). For vllm & huggingface toolkit, this sets the Hugging Face model repo_id (e.g., "Qwen/Qwen3-4B-Instruct-2507"). For lmstudio toolkit, this sets the LM Studio model name (e.g., "qwen/qwen3-4b-thinking-2507").\n
     PORT: Port to run the (Ollama/lmstudio) server on. Defaults to 23333.\n
     CONTEXT_LENGTH: Context length for the (Ollama/lmstudio) model. Defaults to 8192.\n
     """
+    validate_context(ctx)
+    user_id = ctx.obj.current.user_id
     # Resolve the absolute path
     model_path = os.path.abspath(model_path)
 
@@ -176,6 +183,9 @@ def init(
     elif toolkit == 'vllm':
         github_url = DEFAULT_TOOLKIT_MODEL_REPO
         branch = DEFAULT_VLLM_MODEL_REPO_BRANCH
+    elif toolkit == 'python':
+        github_url = DEFAULT_TOOLKIT_MODEL_REPO
+        branch = DEFAULT_PYTHON_MODEL_REPO_BRANCH
 
     if github_url:
         downloader = GitHubDownloader(
@@ -304,15 +314,15 @@ def init(
             logger.error(f"Failed to clone GitHub repository: {e}")
             github_url = None
 
-    if (model_name or port or context_length) and (toolkit == 'ollama'):
-        customize_ollama_model(model_path, model_name, port, context_length)
+    if (user_id or model_name or port or context_length) and (toolkit == 'ollama'):
+        customize_ollama_model(model_path, user_id, model_name, port, context_length)
 
-    if (model_name or port or context_length) and (toolkit == 'lmstudio'):
-        customize_lmstudio_model(model_path, model_name, port, context_length)
+    if (user_id or model_name or port or context_length) and (toolkit == 'lmstudio'):
+        customize_lmstudio_model(model_path, user_id, model_name, port, context_length)
 
-    if model_name and (toolkit == 'huggingface' or toolkit == 'vllm'):
+    if (user_id or model_name) and (toolkit == 'huggingface' or toolkit == 'vllm'):
         # Update the config.yaml file with the provided model name
-        customize_huggingface_model(model_path, model_name)
+        customize_huggingface_model(model_path, user_id, model_name)
 
     if github_url:
         logger.info("Model initialization complete with GitHub repository")
@@ -326,12 +336,20 @@ def init(
         logger.info("Initializing model with default templates...")
         input("Press Enter to continue...")
 
+        from clarifai.cli.base import input_or_default
         from clarifai.cli.templates.model_templates import (
             get_config_template,
             get_model_template,
             get_requirements_template,
         )
 
+        # Collect additional parameters for OpenAI template
+        template_kwargs = {}
+        if model_type_id == "openai":
+            logger.info("Configuring OpenAI local runner...")
+            port = input_or_default("Enter port (default: 8000): ", "8000")
+            template_kwargs = {"port": port}
+
         # Create the 1/ subdirectory
         model_version_dir = os.path.join(model_path, "1")
         os.makedirs(model_version_dir, exist_ok=True)
@@ -341,7 +359,7 @@ def init(
         if os.path.exists(model_py_path):
             logger.warning(f"File {model_py_path} already exists, skipping...")
         else:
-            model_template = get_model_template(model_type_id)
+            model_template = get_model_template(model_type_id, **template_kwargs)
             with open(model_py_path, 'w') as f:
                 f.write(model_template)
             logger.info(f"Created {model_py_path}")
@@ -363,7 +381,9 @@ def init(
         else:
             config_model_type_id = DEFAULT_LOCAL_RUNNER_MODEL_TYPE  # default
 
-            config_template = get_config_template(config_model_type_id)
+            config_template = get_config_template(
+                user_id=user_id, model_type_id=config_model_type_id
+            )
             with open(config_path, 'w') as f:
                 f.write(config_template)
             logger.info(f"Created {config_path}")

{clarifai-11.8.3 → clarifai-11.8.5}/clarifai/cli/templates/model_templates.py

@@ -99,9 +99,9 @@ class MyModel(MCPModelClass):
 '''
 
 
-def get_openai_model_class_template() -> str:
+def get_openai_model_class_template(port: str = "8000") -> str:
     """Return the template for an OpenAIModelClass-based model."""
-    return '''from typing import List
+    return f'''from typing import List, Iterator
 from openai import OpenAI
 from clarifai.runners.models.openai_class import OpenAIModelClass
 from clarifai.runners.utils.data_utils import Param
@@ -114,12 +114,11 @@ class MyModel(OpenAIModelClass):
     # Configure your OpenAI-compatible client for local model
     client = OpenAI(
         api_key="local-key",  # TODO: please fill in - use your local API key
-        base_url="http://localhost:8000/v1",  # TODO: please fill in - your local model server endpoint
+        base_url="http://localhost:{port}/v1",  # TODO: please fill in - your local model server endpoint
     )
 
-    # TODO: please fill in
-    # Specify the model name to use
-    model = "my-local-model"  # TODO: please fill in - replace with your local model name
+    # Automatically get the first available model
+    model = client.models.list().data[0].id
 
     def load_model(self):
         """Optional: Add any additional model loading logic here."""
@@ -157,7 +156,7 @@ class MyModel(OpenAIModelClass):
         max_tokens: int = Param(default=256, description="The maximum number of tokens to generate. Shorter token lengths will provide faster performance."),
         temperature: float = Param(default=1.0, description="A decimal number that determines the degree of randomness in the response"),
         top_p: float = Param(default=1.0, description="An alternative to sampling with temperature, where the model considers the results of the tokens with top_p probability mass."),
-    ):
+    ) -> Iterator[str]:
         """Stream a completion response using the OpenAI client."""
         # TODO: please fill in
         # Implement your streaming logic here
@@ -178,13 +177,13 @@ class MyModel(OpenAIModelClass):
 '''
 
 
-def get_config_template(model_type_id: str = "any-to-any") -> str:
+def get_config_template(user_id: str = None, model_type_id: str = "any-to-any") -> str:
     """Return the template for config.yaml."""
     return f'''# Configuration file for your Clarifai model
 
 model:
   id: "my-model"  # TODO: please fill in - replace with your model ID
-  user_id: "user_id"  # TODO: please fill in - replace with your user ID
+  user_id: "{user_id}"  # TODO: please fill in - replace with your user ID
   app_id: "app_id"  # TODO: please fill in - replace with your app ID
   model_type_id: "{model_type_id}"  # TODO: please fill in - replace if different model type ID
 
@@ -237,8 +236,16 @@ MODEL_TYPE_TEMPLATES = {
 }
 
 
-def get_model_template(model_type_id: str = None) -> str:
+def get_model_template(model_type_id: str = None, **kwargs) -> str:
     """Get the appropriate model template based on model_type_id."""
     if model_type_id in MODEL_TYPE_TEMPLATES:
-        return MODEL_TYPE_TEMPLATES[model_type_id]()
+        template_func = MODEL_TYPE_TEMPLATES[model_type_id]
+        # Check if the template function accepts additional parameters
+        import inspect
+
+        sig = inspect.signature(template_func)
+        if len(sig.parameters) > 0:
+            return template_func(**kwargs)
+        else:
+            return template_func()
     return get_model_class_template()

{clarifai-11.8.3 → clarifai-11.8.5}/clarifai/client/model.py

@@ -108,6 +108,7 @@ class Model(Lister, BaseClient):
         self.training_params = {}
         self.input_types = None
         self._client = None
+        self._async_client = None
         self._added_methods = False
         BaseClient.__init__(
             self,
@@ -528,6 +529,23 @@ class Model(Lister, BaseClient):
             )
         return self._client
 
+    @property
+    def async_client(self):
+        """Get the asynchronous client instance (with async stub)."""
+        if self._async_client is None:
+            request_template = service_pb2.PostModelOutputsRequest(
+                user_app_id=self.user_app_id,
+                model_id=self.id,
+                version_id=self.model_version.id,
+                model=self.model_info,
+                runner_selector=self._runner_selector,
+            )
+            # Create async client with async stub
+            self._async_client = ModelClient(
+                stub=self.STUB, async_stub=self.async_stub, request_template=request_template
+            )
+        return self._async_client
+
     def predict(self, *args, **kwargs):
         """
         Calls the model's predict() method with the given arguments.
@@ -574,16 +592,16 @@ class Model(Lister, BaseClient):
             )
             inference_params = kwargs.get('inference_params', {})
             output_config = kwargs.get('output_config', {})
-            return await self.client._async_predict_by_proto(
+            return await self.async_client._async_predict_by_proto(
                 inputs=inputs, inference_params=inference_params, output_config=output_config
             )
 
         # Adding try-except, since the await works differently with jupyter kernels and in regular python scripts.
         try:
-            return await self.client.predict(*args, **kwargs)
+            return await self.async_client.predict(*args, **kwargs)
         except TypeError:
             # In jupyter, it returns a str object instead of a co-routine.
-            return self.client.predict(*args, **kwargs)
+            return self.async_client.predict(*args, **kwargs)
 
     def __getattr__(self, name):
         try:
@@ -596,7 +614,10 @@ class Model(Lister, BaseClient):
             self.client.fetch()
             for method_name in self.client._method_signatures.keys():
                 if not hasattr(self, method_name):
-                    setattr(self, method_name, getattr(self.client, method_name))
+                    if method_name.startswith('async_'):
+                        setattr(self, method_name, getattr(self.async_client, method_name))
+                    else:
+                        setattr(self, method_name, getattr(self.client, method_name))
         if hasattr(self.client, name):
             return getattr(self.client, name)
         raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
@@ -839,11 +860,11 @@ class Model(Lister, BaseClient):
             )
             inference_params = kwargs.get('inference_params', {})
             output_config = kwargs.get('output_config', {})
-            return self.client._async_generate_by_proto(
+            return self.async_client._async_generate_by_proto(
                 inputs=inputs, inference_params=inference_params, output_config=output_config
             )
 
-        return self.client.generate(*args, **kwargs)
+        return self.async_client.generate(*args, **kwargs)
 
     def generate_by_filepath(
         self,
@@ -1048,11 +1069,11 @@ class Model(Lister, BaseClient):
                 )
                 inference_params = kwargs.get('inference_params', {})
                 output_config = kwargs.get('output_config', {})
-                return self.client._async_stream_by_proto(
+                return self.async_client._async_stream_by_proto(
                     inputs=inputs, inference_params=inference_params, output_config=output_config
                 )
 
-            return self.client.async_stream(*args, **kwargs)
+            return self.async_client.async_stream(*args, **kwargs)
 
     def stream_by_filepath(
         self,

{clarifai-11.8.3 → clarifai-11.8.5}/clarifai/client/model_client.py

@@ -11,6 +11,7 @@ from clarifai.constants.model import MAX_MODEL_PREDICT_INPUTS
 from clarifai.errors import UserError
 from clarifai.runners.utils import code_script, method_signatures
 from clarifai.runners.utils.method_signatures import (
+    RESERVED_PARAM_WITH_PROTO,
     CompatibilitySerializer,
     deserialize,
     get_stream_from_signature,
@@ -204,6 +205,9 @@ class ModelClient:
 
             def bind_f(method_name, method_argnames, call_func, async_call_func):
                 def sync_f(*args, **kwargs):
+                    # Extract with_proto parameter if present
+                    with_proto = kwargs.pop(RESERVED_PARAM_WITH_PROTO, False)
+
                     if len(args) > len(method_argnames):
                         raise TypeError(
                             f"{method_name}() takes {len(method_argnames)} positional arguments but {len(args)} were given"
@@ -221,7 +225,7 @@ class ModelClient:
                         )
                         if is_batch_input_valid and (not is_openai_chat_format(batch_inputs)):
                             # If the batch input is valid, call the function with the batch inputs and the method name
-                            return call_func(batch_inputs, method_name)
+                            return call_func(batch_inputs, method_name, with_proto=with_proto)
 
                     for name, arg in zip(
                         method_argnames, args
@@ -229,10 +233,13 @@ class ModelClient:
                         if name in kwargs:
                             raise TypeError(f"Multiple values for argument {name}")
                         kwargs[name] = arg
-                    return call_func(kwargs, method_name)
+                    return call_func(kwargs, method_name, with_proto=with_proto)
 
                 async def async_f(*args, **kwargs):
                     # Async version to call the async function
+                    # Extract with_proto parameter if present
+                    with_proto = kwargs.pop(RESERVED_PARAM_WITH_PROTO, False)
+
                     if len(args) > len(method_argnames):
                         raise TypeError(
                             f"{method_name}() takes {len(method_argnames)} positional arguments but {len(args)} were given"
@@ -249,7 +256,9 @@ class ModelClient:
                         )
                         if is_batch_input_valid and (not is_openai_chat_format(batch_inputs)):
                             # If the batch input is valid, call the function with the batch inputs and the method name
-                            return async_call_func(batch_inputs, method_name)
+                            return async_call_func(
+                                batch_inputs, method_name, with_proto=with_proto
+                            )
 
                     for name, arg in zip(
                         method_argnames, args
@@ -258,7 +267,7 @@ class ModelClient:
                             raise TypeError(f"Multiple values for argument {name}")
                         kwargs[name] = arg
 
-                    return async_call_func(kwargs, method_name)
+                    return async_call_func(kwargs, method_name, with_proto=with_proto)
 
                 class MethodWrapper:
                     def __call__(self, *args, **kwargs):
@@ -364,6 +373,7 @@ class ModelClient:
         self,
         inputs,  # TODO set up functions according to fetched signatures?
         method_name: str = 'predict',
+        with_proto: bool = False,
     ) -> Any:
         input_signature = self._method_signatures[method_name].input_fields
         output_signature = self._method_signatures[method_name].output_fields
@@ -385,9 +395,12 @@ class ModelClient:
         outputs = []
         for output in response.outputs:
             outputs.append(deserialize(output.data, output_signature, is_output=True))
-        if batch_input:
-            return outputs
-        return outputs[0]
+
+        result = outputs if batch_input else outputs[0]
+
+        if with_proto:
+            return result, response
+        return result
 
     def _predict_by_proto(
         self,
@@ -448,15 +461,17 @@ class ModelClient:
         self,
         inputs,
         method_name: str = 'predict',
+        with_proto: bool = False,
     ) -> Any:
         """Asynchronously process inputs and make predictions.
 
         Args:
             inputs: Input data to process
             method_name (str): Name of the method to call
+            with_proto (bool): If True, return both the processed result and the raw protobuf response
 
         Returns:
-            Processed prediction results
+            Processed prediction results, optionally with protobuf response
         """
         # method_name is set to 'predict' by default, this is because to replicate the input and output signature behaviour of sync to async predict.
         input_signature = self._method_signatures[method_name].input_fields
@@ -477,7 +492,11 @@ class ModelClient:
         for output in response.outputs:
             outputs.append(deserialize(output.data, output_signature, is_output=True))
 
-        return outputs if batch_input else outputs[0]
+        result = outputs if batch_input else outputs[0]
+
+        if with_proto:
+            return result, response
+        return result
 
     async def _async_predict_by_proto(
         self,
@@ -551,6 +570,7 @@ class ModelClient:
         self,
         inputs,  # TODO set up functions according to fetched signatures?
         method_name: str = 'generate',
+        with_proto: bool = False,
     ) -> Any:
         input_signature = self._method_signatures[method_name].input_fields
         output_signature = self._method_signatures[method_name].output_fields
@@ -572,10 +592,13 @@ class ModelClient:
             outputs = []
             for output in response.outputs:
                 outputs.append(deserialize(output.data, output_signature, is_output=True))
-            if batch_input:
-                yield outputs
+
+            result = outputs if batch_input else outputs[0]
+
+            if with_proto:
+                yield result, response
             else:
-                yield outputs[0]
+                yield result
 
     def _generate_by_proto(
         self,
@@ -641,6 +664,7 @@ class ModelClient:
         self,
         inputs,
         method_name: str = 'generate',
+        with_proto: bool = False,
     ) -> Any:
         # method_name is set to 'generate' by default, this is because to replicate the input and output signature behaviour of sync to async generate.
         input_signature = self._method_signatures[method_name].input_fields
@@ -654,18 +678,21 @@ class ModelClient:
         proto_inputs = []
         for input in inputs:
             proto = resources_pb2.Input()
-        serialize(input, input_signature, proto.data)
-        proto_inputs.append(proto)
+            serialize(input, input_signature, proto.data)
+            proto_inputs.append(proto)
         response_stream = self._async_generate_by_proto(proto_inputs, method_name)
 
         async for response in response_stream:
             outputs = []
             for output in response.outputs:
                 outputs.append(deserialize(output.data, output_signature, is_output=True))
-            if batch_input:
-                yield outputs
+
+            result = outputs if batch_input else outputs[0]
+
+            if with_proto:
+                yield result, response
             else:
-                yield outputs[0]
+                yield result
 
     async def _async_generate_by_proto(
         self,
@@ -734,6 +761,7 @@ class ModelClient:
         self,
         inputs,
         method_name: str = 'stream',
+        with_proto: bool = False,
     ) -> Any:
         input_signature = self._method_signatures[method_name].input_fields
         output_signature = self._method_signatures[method_name].output_fields
@@ -775,7 +803,12 @@ class ModelClient:
 
         for response in response_stream:
             assert len(response.outputs) == 1, 'streaming methods must have exactly one output'
-            yield deserialize(response.outputs[0].data, output_signature, is_output=True)
+            result = deserialize(response.outputs[0].data, output_signature, is_output=True)
+
+            if with_proto:
+                yield result, response
+            else:
+                yield result
 
     def _req_iterator(
         self,
@@ -843,6 +876,7 @@ class ModelClient:
         self,
         inputs,
         method_name: str = 'stream',
+        with_proto: bool = False,
     ) -> Any:
         # method_name is set to 'stream' by default, this is because to replicate the input and output signature behaviour of sync to async stream.
         input_signature = self._method_signatures[method_name].input_fields
@@ -885,7 +919,12 @@ class ModelClient:
 
         async for response in response_stream:
             assert len(response.outputs) == 1, 'streaming methods must have exactly one output'
-            yield deserialize(response.outputs[0].data, output_signature, is_output=True)
+            result = deserialize(response.outputs[0].data, output_signature, is_output=True)
+
+            if with_proto:
+                yield result, response
+            else:
+                yield result
 
     async def _async_stream_by_proto(
         self,

{clarifai-11.8.3 → clarifai-11.8.5}/clarifai/runners/utils/method_signatures.py

@@ -23,6 +23,9 @@ from clarifai.runners.utils.serializers import (
     TupleSerializer,
 )
 
+# Reserved parameter name for protobuf response access
+RESERVED_PARAM_WITH_PROTO = 'with_proto'
+
 
 def build_function_signature(func):
     '''
@@ -45,6 +48,12 @@ def build_function_signature(func):
     input_sigs = []
     input_streaming = []
     for p in sig.parameters.values():
+        # Validate that user methods don't use reserved parameter names
+        if p.name == RESERVED_PARAM_WITH_PROTO:
+            raise ValueError(
+                f"Parameter name '{RESERVED_PARAM_WITH_PROTO}' is reserved and cannot be used in model methods. "
+                f"This parameter is automatically added by the framework to provide access to protobuf responses."
+            )
         model_type_field, _, streaming = build_variable_signature(p.name, p.annotation, p.default)
         input_sigs.append(model_type_field)
         input_streaming.append(streaming)

{clarifai-11.8.3 → clarifai-11.8.5}/clarifai/utils/cli.py

@@ -229,7 +229,7 @@ def validate_context_auth(pat: str, user_id: str, api_base: str = None):
 
 
 def customize_ollama_model(
-    model_path, model_name=None, port=None, context_length=None, verbose=False
+    model_path, user_id, model_name=None, port=None, context_length=None, verbose=False
 ):
     """Customize the Ollama model name in the cloned template files.
     Args:
@@ -240,6 +240,24 @@ def customize_ollama_model(
      verbose: Whether to enable verbose logging - optional (defaults to False)
 
     """
+    config_path = os.path.join(model_path, 'config.yaml')
+    if os.path.exists(config_path):
+        with open(config_path, 'r') as f:
+            config = yaml.safe_load(f)
+
+        # Update the user_id in the model section
+        config['model']['user_id'] = user_id
+        if 'toolkit' not in config or config['toolkit'] is None:
+            config['toolkit'] = {}
+        if model_name is not None:
+            config['toolkit']['model'] = model_name
+        if port is not None:
+            config['toolkit']['port'] = port
+        if context_length is not None:
+            config['toolkit']['context_length'] = context_length
+        with open(config_path, 'w') as f:
+            yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+
     model_py_path = os.path.join(model_path, "1", "model.py")
 
     if not os.path.exists(model_py_path):
@@ -405,16 +423,20 @@ def convert_timestamp_to_string(timestamp: Timestamp) -> str:
     return datetime_obj.strftime('%Y-%m-%dT%H:%M:%SZ')
 
 
-def customize_huggingface_model(model_path, model_name):
+def customize_huggingface_model(model_path, user_id, model_name):
     config_path = os.path.join(model_path, 'config.yaml')
     if os.path.exists(config_path):
         with open(config_path, 'r') as f:
             config = yaml.safe_load(f)
 
-        # Update the repo_id in checkpoints section
-        if 'checkpoints' not in config:
-            config['checkpoints'] = {}
-        config['checkpoints']['repo_id'] = model_name
+        # Update the user_id in the model section
+        config['model']['user_id'] = user_id
+
+        if model_name:
+            # Update the repo_id in checkpoints section
+            if 'checkpoints' not in config:
+                config['checkpoints'] = {}
+            config['checkpoints']['repo_id'] = model_name
 
         with open(config_path, 'w') as f:
             yaml.dump(config, f, default_flow_style=False, sort_keys=False)
@@ -424,7 +446,7 @@ def customize_huggingface_model(model_path, model_name):
         logger.warning(f"config.yaml not found at {config_path}, skipping model configuration")
 
 
-def customize_lmstudio_model(model_path, model_name, port, context_length):
+def customize_lmstudio_model(model_path, user_id, model_name, port, context_length):
     """Customize the LM Studio model name in the cloned template files.
     Args:
      model_path: Path to the cloned model directory
@@ -438,6 +460,8 @@ def customize_lmstudio_model(model_path, model_name, port, context_length):
     if os.path.exists(config_path):
         with open(config_path, 'r') as f:
             config = yaml.safe_load(f)
+        # Update the user_id in the model section
+        config['model']['user_id'] = user_id
         if 'toolkit' not in config or config['toolkit'] is None:
             config['toolkit'] = {}
         if model_name is not None:

{clarifai-11.8.3 → clarifai-11.8.5}/clarifai/utils/constants.py

@@ -66,6 +66,7 @@ DEFAULT_OLLAMA_MODEL_REPO_BRANCH = "ollama"
 DEFAULT_HF_MODEL_REPO_BRANCH = "huggingface"
 DEFAULT_LMSTUDIO_MODEL_REPO_BRANCH = "lmstudio"
 DEFAULT_VLLM_MODEL_REPO_BRANCH = "vllm"
+DEFAULT_PYTHON_MODEL_REPO_BRANCH = "python"
 
 STATUS_OK = "200 OK"
 STATUS_MIXED = "207 MIXED"

{clarifai-11.8.3 → clarifai-11.8.5/clarifai.egg-info}/PKG-INFO

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

{clarifai-11.8.3 → clarifai-11.8.5}/clarifai.egg-info/SOURCES.txt

@@ -148,4 +148,5 @@ tests/test_pipeline_client.py
 tests/test_rag.py
 tests/test_search.py
 tests/test_secrets.py
-tests/test_stub.py
+tests/test_stub.py
+tests/test_with_proto_feature.py