clarifai 11.8.1__py3-none-any.whl → 11.8.3__py3-none-any.whl

clarifai/runners/pipelines/pipeline_builder.py

@@ -116,13 +116,33 @@ class PipelineBuilder:
         return True
 
     def _upload_pipeline_step_with_version_capture(self, step_path: str) -> tuple[bool, str]:
-        """Upload a pipeline step and capture its version ID."""
+        """
+        Upload a pipeline step and capture its version ID.
+        Implements hash-based optimization to only upload modified steps.
+        """
         try:
             # Use the existing pipeline step builder
             from clarifai.runners.pipeline_steps.pipeline_step_builder import PipelineStepBuilder
 
             builder = PipelineStepBuilder(step_path)
 
+            # Check if we should upload based on hash comparison
+            should_upload = builder.should_upload_step()
+
+            if not should_upload:
+                # Load existing version ID from config-lock.yaml
+                config_lock = builder.load_config_lock()
+                if config_lock and config_lock.get("id"):
+                    version_id = config_lock["id"]
+                    logger.info(
+                        f"Using existing pipeline step version {version_id} (no changes detected)"
+                    )
+                    return True, version_id
+                else:
+                    logger.warning(
+                        "Hash indicates no upload needed, but no version ID found in config-lock.yaml. Proceeding with upload."
+                    )
+
             # Create dockerfile if needed
             builder.create_dockerfile()
 
@@ -139,6 +159,11 @@ class PipelineBuilder:
             success = builder.upload_pipeline_step_version()
 
             if success and builder.pipeline_step_version_id:
+                # Generate config-lock.yaml with the new version ID
+                builder.save_config_lock(builder.pipeline_step_version_id)
+                logger.info(
+                    f"Generated config-lock.yaml for pipeline step with version {builder.pipeline_step_version_id}"
+                )
                 return True, builder.pipeline_step_version_id
             else:
                 logger.error("Failed to get pipeline step version ID after upload")
@@ -148,42 +173,105 @@ class PipelineBuilder:
             logger.error(f"Error uploading pipeline step: {e}")
             return False, ""
 
-    def update_config_with_versions(self) -> None:
-        """Update the config.yaml with uploaded pipeline step versions."""
+    def prepare_lockfile_with_step_versions(self) -> Dict[str, Any]:
+        """Prepare lockfile data with step versions after pipeline step upload."""
         if not self.uploaded_step_versions:
-            logger.info("No pipeline step versions to update in config")
-            return
-
-        logger.info("Updating config.yaml with pipeline step versions...")
+            logger.info("No pipeline step versions for lockfile")
 
-        # Update the orchestration spec
+        # Create a copy of the orchestration spec to modify
         pipeline_config = self.config["pipeline"]
-        orchestration_spec = pipeline_config["orchestration_spec"]
+        orchestration_spec = pipeline_config["orchestration_spec"].copy()
         argo_spec_str = orchestration_spec["argo_orchestration_spec"]
         argo_spec = yaml.safe_load(argo_spec_str)
 
         # Update templateRef names to include versions
         self._update_template_refs_with_versions(argo_spec)
 
-        # Update the config
-        orchestration_spec["argo_orchestration_spec"] = yaml.dump(
-            argo_spec, Dumper=LiteralBlockDumper, default_flow_style=False
-        )
+        # Create the partial lockfile data structure (without pipeline info)
+        lockfile_data = {
+            "pipeline": {
+                "id": self.pipeline_id,
+                "user_id": self.user_id,
+                "app_id": self.app_id,
+                "version_id": None,  # Will be filled in later
+                "orchestration_spec": {
+                    "argo_orchestration_spec": yaml.dump(
+                        argo_spec, Dumper=LiteralBlockDumper, default_flow_style=False
+                    )
+                },
+            }
+        }
+
+        return lockfile_data
+
+    def update_lockfile_with_pipeline_info(
+        self, lockfile_data: Dict[str, Any], pipeline_version_id: str
+    ) -> Dict[str, Any]:
+        """Update the prepared lockfile data with pipeline version information."""
+        lockfile_data["pipeline"]["version_id"] = pipeline_version_id
+        return lockfile_data
+
+    def generate_lockfile_data(
+        self, pipeline_id: str = None, pipeline_version_id: str = None
+    ) -> Dict[str, Any]:
+        """Generate the complete lockfile data structure without modifying config.yaml.
+
+        This method is kept for backward compatibility. The recommended approach is to use
+        prepare_lockfile_with_step_versions() followed by update_lockfile_with_pipeline_info().
+        """
+        if not self.uploaded_step_versions:
+            logger.info("No pipeline step versions for lockfile")
 
-        # Remove uploaded directories from step_directories
-        remaining_dirs = []
-        for step_dir in pipeline_config.get("step_directories", []):
-            if step_dir not in self.uploaded_step_versions:
-                remaining_dirs.append(step_dir)
+        # Create a copy of the orchestration spec to modify
+        pipeline_config = self.config["pipeline"]
+        orchestration_spec = pipeline_config["orchestration_spec"].copy()
+        argo_spec_str = orchestration_spec["argo_orchestration_spec"]
+        argo_spec = yaml.safe_load(argo_spec_str)
 
-        pipeline_config["step_directories"] = remaining_dirs
+        # Update templateRef names to include versions
+        self._update_template_refs_with_versions(argo_spec)
+
+        # Create the lockfile data structure
+        lockfile_data = {
+            "pipeline": {
+                "id": pipeline_id or self.pipeline_id,
+                "user_id": self.user_id,
+                "app_id": self.app_id,
+                "version_id": pipeline_version_id,
+                "orchestration_spec": {
+                    "argo_orchestration_spec": yaml.dump(
+                        argo_spec, Dumper=LiteralBlockDumper, default_flow_style=False
+                    )
+                },
+            }
+        }
+
+        return lockfile_data
+
+    def save_lockfile(self, lockfile_data: Dict[str, Any], lockfile_path: str = None) -> None:
+        """Save lockfile data to config-lock.yaml."""
+        if lockfile_path is None:
+            lockfile_path = os.path.join(self.config_dir, "config-lock.yaml")
 
-        # Save the updated config
-        self._save_config()
-        logger.info("Updated config.yaml with pipeline step versions")
+        try:
+            with open(lockfile_path, 'w', encoding="utf-8") as file:
+                yaml.dump(
+                    lockfile_data,
+                    file,
+                    Dumper=LiteralBlockDumper,
+                    default_flow_style=False,
+                    sort_keys=False,
+                )
+            logger.info(f"Generated lockfile: {lockfile_path}")
+        except Exception as e:
+            raise ValueError(f"Error saving lockfile {lockfile_path}: {e}")
 
     def _update_template_refs_with_versions(self, argo_spec: Dict[str, Any]) -> None:
-        """Update templateRef names in Argo spec to include version information."""
+        """
+        Update templateRef names in Argo spec to include version information.
+        The step versions should be resolved from the corresponding config-lock.yaml
+        file of each pipeline-step, located in the step_directories.
+        """
         for template in argo_spec["spec"]["templates"]:
             if "steps" in template:
                 for step_group in template["steps"]:
@@ -199,12 +287,19 @@ class PipelineBuilder:
                                 step_name = parts[-1]
                                 # The step name should match the directory name or be derivable from it
                                 version_id = self.uploaded_step_versions.get(step_name, None)
+
+                                # If not found in uploaded_step_versions, try to get from config-lock.yaml
+                                if version_id is None:
+                                    version_id = self._get_version_from_config_lock(step_name)
+
                                 if version_id is not None:
                                     # Update the templateRef to include version
                                     new_name = f"{name}/versions/{version_id}"
                                     template_ref["name"] = new_name
                                     template_ref["template"] = new_name
                                     logger.info(f"Updated templateRef from {name} to {new_name}")
+                                else:
+                                    logger.warning(f"Could not find version for step: {step_name}")
                             elif self.validator.TEMPLATE_REF_WITH_VERSION_PATTERN.match(name):
                                 # strip the /versions/{version_id} from the end of name
                                 # to get the name like above
@@ -215,6 +310,11 @@ class PipelineBuilder:
                                 # if it already has a version, make sure it matches the uploaded
                                 # version
                                 version_id = self.uploaded_step_versions.get(step_name, None)
+
+                                # If not found in uploaded_step_versions, try to get from config-lock.yaml
+                                if version_id is None:
+                                    version_id = self._get_version_from_config_lock(step_name)
+
                                 if version_id is not None:
                                     # Update the templateRef to include version
                                     new_name = f"{name}/versions/{version_id}"
@@ -223,9 +323,51 @@ class PipelineBuilder:
                                     logger.info(
                                         f"Updated templateRef from {orig_name} to {new_name}"
                                     )
+                                else:
+                                    logger.warning(f"Could not find version for step: {step_name}")
+
+    def _get_version_from_config_lock(self, step_name: str) -> str:
+        """
+        Get version ID from config-lock.yaml file in the corresponding step directory.
 
-    def create_pipeline(self) -> bool:
-        """Create the pipeline using PostPipelines RPC."""
+        :param step_name: Name of the pipeline step
+        :return: Version ID if found, None otherwise
+        """
+        pipeline_config = self.config["pipeline"]
+        step_directories = pipeline_config.get("step_directories", [])
+
+        for step_dir in step_directories:
+            # Check if step_dir matches step_name (handle both exact match and derivable cases)
+            if (
+                step_dir == step_name
+                or step_dir.endswith(f"/{step_name}")
+                or step_name in step_dir
+            ):
+                config_lock_path = os.path.join(self.config_dir, step_dir, "config-lock.yaml")
+
+                if os.path.exists(config_lock_path):
+                    try:
+                        with open(config_lock_path, 'r', encoding='utf-8') as f:
+                            config_lock = yaml.safe_load(f)
+                            version_id = config_lock.get("id")
+                            if version_id:
+                                logger.info(
+                                    f"Found version {version_id} for step {step_name} in {config_lock_path}"
+                                )
+                                return version_id
+                    except Exception as e:
+                        logger.warning(
+                            f"Failed to read config-lock.yaml at {config_lock_path}: {e}"
+                        )
+
+        return None
+
+    def create_pipeline(self) -> tuple[bool, str]:
+        """Create the pipeline using PostPipelines RPC.
+
+        Returns:
+            tuple[bool, str]: (success, pipeline_version_id)
+        """
         logger.info(f"Creating pipeline {self.pipeline_id}...")
 
         try:
@@ -243,6 +385,11 @@ class PipelineBuilder:
             argo_spec = yaml.safe_load(argo_spec_str)
             api_version = argo_spec.get("apiVersion", "argoproj.io/v1alpha1")
 
+            # Ensure that pipeline_config.argo_orchestration_spec_proto has the updated spec.templates.steps.templateRef values
+            # For each step, if the templateRef is missing a version, append the correct version at the end
+            # The step versions should be resolved from the corresponding config-lock.yaml file of each pipeline-step, located in the step_directories
+            self._update_template_refs_with_versions(argo_spec)
+
             # Create pipeline version with orchestration spec
             pipeline_version = resources_pb2.PipelineVersion()
             # Create orchestration spec proto
@@ -269,29 +416,32 @@ class PipelineBuilder:
             if response.status.code == status_code_pb2.SUCCESS:
                 logger.info(f"Successfully created pipeline {self.pipeline_id}")
 
+                pipeline_version_id = ""
                 # Log pipeline and version IDs if available in response
                 if response.pipelines:
                     created_pipeline = response.pipelines[0]
                     logger.info(f"Pipeline ID: {created_pipeline.id}")
                     if created_pipeline.pipeline_version and created_pipeline.pipeline_version.id:
-                        logger.info(f"Pipeline version ID: {created_pipeline.pipeline_version.id}")
+                        pipeline_version_id = created_pipeline.pipeline_version.id
+                        logger.info(f"Pipeline version ID: {pipeline_version_id}")
 
-                return True
+                return True, pipeline_version_id
             else:
                 logger.error(f"Failed to create pipeline: {response.status.description}")
                 logger.error(f"Details: {response.status.details}")
-                return False
+                return False, ""
 
         except Exception as e:
             logger.error(f"Error creating pipeline: {e}")
-            return False
+            return False, ""
 
 
-def upload_pipeline(path: str):
+def upload_pipeline(path: str, no_lockfile: bool = False):
     """
     Upload a pipeline with associated pipeline steps to Clarifai.
 
     :param path: Path to the pipeline configuration file or directory containing config.yaml
+    :param no_lockfile: If True, skip creating config-lock.yaml
     """
     try:
         # Determine if path is a directory or file
@@ -311,15 +461,27 @@ def upload_pipeline(path: str):
             logger.error("Failed to upload pipeline steps")
             sys.exit(1)
 
-        # Step 2: Update config with version information
-        builder.update_config_with_versions()
+        # Step 2: Generate lockfile (unless --no-lockfile is specified)
+        # This will be used to update the versions of pipeline-steps that just got uploaded in Step 1
+        lockfile_data = None
+        if not no_lockfile:
+            lockfile_data = builder.prepare_lockfile_with_step_versions()
 
         # Step 3: Create the pipeline
-        if not builder.create_pipeline():
+        success, pipeline_version_id = builder.create_pipeline()
+        if not success:
             logger.error("Failed to create pipeline")
             sys.exit(1)
 
-        logger.info("Pipeline upload completed successfully!")
+        # Step 4: Update lockfile (unless --no-lockfile is specified)
+        if not no_lockfile and lockfile_data:
+            lockfile_data = builder.update_lockfile_with_pipeline_info(
+                lockfile_data, pipeline_version_id
+            )
+            builder.save_lockfile(lockfile_data)
+            logger.info("Pipeline upload completed successfully with lockfile!")
+        else:
+            logger.info("Pipeline upload completed successfully (lockfile skipped)!")
 
     except Exception as e:
         logger.error(f"Pipeline upload failed: {e}")

clarifai/runners/server.py

@@ -290,6 +290,7 @@ class ModelServer:
                 model_id=context.model_id,
                 deployment_id=context.deployment_id,
                 base_url=context.api_base,
+                colorize=True,
             )
             logger.info(
                 "✅ Your model is running locally and is ready for requests from the API...\n"

clarifai/runners/utils/code_script.py

@@ -33,6 +33,7 @@ def generate_client_script(
     compute_cluster_id: str = None,
     nodepool_id: str = None,
     use_ctx: bool = False,
+    colorize: bool = False,
 ) -> str:
     url_helper = ClarifaiUrlHelper()
 
@@ -91,7 +92,7 @@ response = client.chat.completions.create(
             "content": "How do I check if a Python object is an instance of a class?",
         }},
     ],
-    temperature=0.7,
+    temperature=1.0,
     stream=False,  # stream=True also works, just iterator over the response
 )
 print(response)
@@ -203,6 +204,16 @@ model = Model.from_current_context()
     script_lines.append(method_signatures_str)
     script_lines.append("")
     script = "\n".join(script_lines)
+    if colorize:
+        try:
+            from pygments import highlight  # type: ignore
+            from pygments.formatters import TerminalFormatter  # type: ignore
+            from pygments.lexers import PythonLexer  # type: ignore
+
+            return highlight(script, PythonLexer(), TerminalFormatter())
+        except Exception:
+            # Fallback to plain text if pygments is unavailable
+            return script
     return script
 
 

clarifai/utils/cli.py

@@ -298,6 +298,20 @@ def check_ollama_installed():
         return False
 
 
+def check_lmstudio_installed():
+    """Check if the LM Studio CLI is installed."""
+    try:
+        import subprocess
+
+        result = subprocess.run(['lms', 'version'], capture_output=True, text=True, check=False)
+        if result.returncode == 0:
+            return True
+        else:
+            return False
+    except FileNotFoundError:
+        return False
+
+
 def _is_package_installed(package_name):
     """Helper function to check if a single package in requirements.txt is installed."""
     import importlib.metadata
@@ -389,3 +403,51 @@ def convert_timestamp_to_string(timestamp: Timestamp) -> str:
     datetime_obj = timestamp.ToDatetime()
 
     return datetime_obj.strftime('%Y-%m-%dT%H:%M:%SZ')
+
+
+def customize_huggingface_model(model_path, 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
+
+        with open(config_path, 'w') as f:
+            yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+
+        logger.info(f"Updated Hugging Face model repo_id to: {model_name}")
+    else:
+        logger.warning(f"config.yaml not found at {config_path}, skipping model configuration")
+
+
+def customize_lmstudio_model(model_path, 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
+     model_name: The model name to set (e.g., 'qwen/qwen3-4b-thinking-2507') - optional
+     port: Port for LM Studio server - optional
+     context_length: Context length for the model - optional
+
+    """
+    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)
+        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)
+        logger.info(f"Updated LM Studio model configuration in: {config_path}")
+    else:
+        logger.warning(f"config.yaml not found at {config_path}, skipping model configuration")

clarifai/utils/constants.py

@@ -21,8 +21,7 @@ DEFAULT_LOCAL_RUNNER_DEPLOYMENT_ID = "local-runner-deployment"
 DEFAULT_LOCAL_RUNNER_MODEL_ID = "local-runner-model"
 DEFAULT_LOCAL_RUNNER_APP_ID = "local-runner-app"
 
-# FIXME: should have any-to-any for these cases.
-DEFAULT_LOCAL_RUNNER_MODEL_TYPE = "text-to-text"
+DEFAULT_LOCAL_RUNNER_MODEL_TYPE = "any-to-any"
 
 DEFAULT_LOCAL_RUNNER_COMPUTE_CLUSTER_CONFIG = {
     "compute_cluster": {
@@ -62,8 +61,11 @@ DEFAULT_LOCAL_RUNNER_NODEPOOL_CONFIG = {
         "max_instances": 1,
     }
 }
-DEFAULT_OLLAMA_MODEL_REPO = "https://github.com/Clarifai/runners-examples"
+DEFAULT_TOOLKIT_MODEL_REPO = "https://github.com/Clarifai/runners-examples"
 DEFAULT_OLLAMA_MODEL_REPO_BRANCH = "ollama"
+DEFAULT_HF_MODEL_REPO_BRANCH = "huggingface"
+DEFAULT_LMSTUDIO_MODEL_REPO_BRANCH = "lmstudio"
+DEFAULT_VLLM_MODEL_REPO_BRANCH = "vllm"
 
 STATUS_OK = "200 OK"
 STATUS_MIXED = "207 MIXED"

clarifai/utils/hashing.py

@@ -0,0 +1,117 @@
+"""
+Hashing utilities for Clarifai Python SDK.
+
+This module provides functions for computing stable hashes of directories and files,
+commonly used for change detection in pipeline steps and other components.
+"""
+
+import hashlib
+import os
+from typing import List, Optional
+
+
+def hash_directory(
+    directory: str, algo: str = "md5", exclude_files: Optional[List[str]] = None
+) -> str:
+    """
+    Compute a stable hash of all files in a directory.
+
+    This function computes a hash that accounts for:
+    - File relative paths (to detect renames)
+    - File sizes (to detect empty files)
+    - File contents (read in chunks for large files)
+
+    :param directory: Directory to hash
+    :param algo: Hash algorithm ('md5', 'sha1', 'sha256', etc.)
+    :param exclude_files: List of file names to exclude from hash calculation.
+                         If None, defaults to ['config-lock.yaml'] for backward compatibility.
+    :return: Hash as lowercase hex digest string
+    """
+    if exclude_files is None:
+        exclude_files = ['config-lock.yaml']
+
+    # Ensure directory exists
+    if not os.path.exists(directory):
+        raise ValueError(f"Directory does not exist: {directory}")
+
+    if not os.path.isdir(directory):
+        raise ValueError(f"Path is not a directory: {directory}")
+
+    hash_func = hashlib.new(algo)
+
+    for root, _, files in os.walk(directory):
+        for name in sorted(files):
+            # Skip files in the exclusion list
+            if name in exclude_files:
+                continue
+
+            filepath = os.path.join(root, name)
+            relative_path = os.path.relpath(filepath, directory)
+
+            # Hash the relative path to detect renames
+            hash_func.update(relative_path.encode("utf-8"))
+
+            # Hash the file size to detect empties
+            file_size = os.path.getsize(filepath)
+            hash_func.update(str(file_size).encode("utf-8"))
+
+            # Hash the file contents (read in chunks for large files)
+            try:
+                with open(filepath, "rb") as f:
+                    for chunk in iter(lambda: f.read(8192), b""):
+                        hash_func.update(chunk)
+            except (IOError, OSError) as e:
+                # If we can't read the file, include the error in the hash
+                # This ensures the hash changes if file permissions change
+                hash_func.update(f"ERROR_READING_FILE: {e}".encode("utf-8"))
+
+    return hash_func.hexdigest()
+
+
+def hash_file(filepath: str, algo: str = "md5") -> str:
+    """
+    Compute a hash of a single file.
+
+    :param filepath: Path to the file to hash
+    :param algo: Hash algorithm ('md5', 'sha1', 'sha256', etc.)
+    :return: Hash as lowercase hex digest string
+    """
+    if not os.path.exists(filepath):
+        raise ValueError(f"File does not exist: {filepath}")
+
+    if not os.path.isfile(filepath):
+        raise ValueError(f"Path is not a file: {filepath}")
+
+    hash_func = hashlib.new(algo)
+
+    try:
+        with open(filepath, "rb") as f:
+            for chunk in iter(lambda: f.read(8192), b""):
+                hash_func.update(chunk)
+    except (IOError, OSError) as e:
+        raise ValueError(f"Error reading file {filepath}: {e}")
+
+    return hash_func.hexdigest()
+
+
+def verify_hash_algorithm(algo: str) -> bool:
+    """
+    Verify that a hash algorithm is supported.
+
+    :param algo: Hash algorithm name
+    :return: True if algorithm is supported, False otherwise
+    """
+    try:
+        hashlib.new(algo)
+        return True
+    except ValueError:
+        return False
+
+
+def get_available_algorithms() -> List[str]:
+    """
+    Get list of available hash algorithms.
+
+    :return: List of available algorithm names
+    """
+    return list(hashlib.algorithms_available)

clarifai/utils/secrets.py

@@ -1,3 +1,5 @@
+# NOTE(alan): Most of this file is used to support hot reloading of secrets, which has been disabled for now.
+
 import os
 import time
 from contextlib import contextmanager
@@ -149,8 +151,11 @@ def inject_secrets(request: Optional[service_pb2.PostModelOutputsRequest]) -> No
         # Since only env type secrets are injected into the shared volume, we can read them directly.
         variables = get_env_variable(secrets_path)
     else:
-        # If no secrets path is set, assume no secrets and return the request as is.
-        return
+        # If no secrets path is set, use variables from the current environment
+        variables = {}
+        for key, value in os.environ.items():
+            if not key.startswith("CLARIFAI"):
+                variables[key] = value
 
     if not request.HasField("model"):
         request.model.CopyFrom(resources_pb2.Model())

{clarifai-11.8.1.dist-info → clarifai-11.8.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.8.1
+Version: 11.8.3
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
 Author-email: support@clarifai.com
@@ -19,8 +19,8 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: clarifai-grpc>=11.7.9
-Requires-Dist: clarifai-protocol>=0.0.30
+Requires-Dist: clarifai-grpc>=11.8.2
+Requires-Dist: clarifai-protocol>=0.0.32
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: tqdm>=4.65.0
 Requires-Dist: PyYAML>=6.0.1
@@ -34,6 +34,7 @@ Requires-Dist: aiohttp>=3.10.0
 Requires-Dist: uv==0.7.12
 Requires-Dist: ruff==0.11.4
 Requires-Dist: psutil==7.0.0
+Requires-Dist: pygments>=2.19.2
 Requires-Dist: pydantic_core==2.33.2
 Requires-Dist: packaging==25.0
 Provides-Extra: all