foundry-local-sdk 0.3.0__py3-none-any.whl

foundry_local/__init__.py

@@ -0,0 +1,23 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+# --------------------------------------------------------------------------
+import logging
+import sys
+
+from foundry_local.api import FoundryLocalManager
+
+_logger = logging.getLogger(__name__)
+_logger.setLevel(logging.WARNING)
+
+_sc = logging.StreamHandler(stream=sys.stdout)
+_formatter = logging.Formatter(
+    "[foundry-local] | %(asctime)s | %(levelname)-8s | %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
+)
+_sc.setFormatter(_formatter)
+_logger.addHandler(_sc)
+_logger.propagate = False
+
+__all__ = ["FoundryLocalManager"]
+
+__version__ = "0.3.0"

foundry_local/api.py

@@ -0,0 +1,333 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+# --------------------------------------------------------------------------
+from __future__ import annotations
+
+import logging
+import os
+import platform
+
+from httpx import Timeout
+
+from foundry_local.client import HttpResponseError, HttpxClient
+from foundry_local.models import ExecutionProvider, FoundryModelInfo
+from foundry_local.service import assert_foundry_installed, get_service_uri, start_service
+
+logger = logging.getLogger(__name__)
+
+
+class FoundryLocalManager:
+    """Manager for Foundry Local SDK operations."""
+
+    def __init__(
+        self, alias_or_model_id: str | None = None, bootstrap: bool = True, timeout: float | Timeout | None = None
+    ):
+        """
+        Initialize the Foundry Local SDK.
+
+        Args:
+            alias_or_model_id (str | None): Alias or Model ID to download and load. Only used if bootstrap is True.
+            bootstrap (bool): If True, start the service if it is not running.
+            timeout (float | Timeout | None): Timeout for the HTTP client. Default is None.
+        """
+        assert_foundry_installed()
+        self._timeout = timeout
+        self._service_uri = None
+        self._httpx_client = None
+        self._set_service_uri_and_client(get_service_uri())
+        self._catalog_list = None
+        self._catalog_dict = None
+        if bootstrap:
+            self.start_service()
+            if alias_or_model_id is not None:
+                self.download_model(alias_or_model_id)
+                self.load_model(alias_or_model_id)
+
+    def _set_service_uri_and_client(self, service_uri: str | None):
+        """
+        Set the service URI and HTTP client.
+
+        Args:
+            service_uri (str | None): URI of the Foundry service.
+        """
+        self._service_uri = service_uri
+        self._httpx_client = HttpxClient(service_uri, timeout=self._timeout) if service_uri else None
+
+    @property
+    def service_uri(self) -> str:
+        """
+        Get the service URI.
+
+        Returns:
+            str: URI of the Foundry service.
+
+        Raises:
+            RuntimeError: If the service URI is not set.
+        """
+        if self._service_uri is None:
+            raise RuntimeError("Service URI is not set. Please start the service first.")
+        return self._service_uri
+
+    @property
+    def httpx_client(self) -> HttpxClient:
+        """
+        Get the HTTP client.
+
+        Returns:
+            HttpxClient: HTTP client instance.
+
+        Raises:
+            RuntimeError: If the HTTP client is not set.
+        """
+        if self._httpx_client is None:
+            raise RuntimeError("Httpx client is not set. Please start the service first.")
+        return self._httpx_client
+
+    @property
+    def endpoint(self) -> str:
+        """
+        Get the endpoint for the service.
+
+        Returns:
+            str: Endpoint URL.
+        """
+        return f"{self.service_uri}/v1"
+
+    @property
+    def api_key(self) -> str:
+        """
+        Get the API key for authentication.
+
+        Returns:
+            str: API key.
+        """
+        return os.getenv("OPENAI_API_KEY") or "OPENAI_API_KEY"
+
+    # Service management api
+    def is_service_running(self) -> bool:
+        """
+        Check if the service is running. Will also set the service URI if it is not set.
+
+        Returns:
+            bool: True if the service is running, False otherwise.
+        """
+        self._set_service_uri_and_client(get_service_uri())
+        return self._service_uri is not None
+
+    def start_service(self):
+        """Start the service."""
+        self._set_service_uri_and_client(start_service())
+
+    # Catalog api
+    def list_catalog_models(self) -> list[FoundryModelInfo]:
+        """
+        Get a list of available models in the catalog.
+
+        Returns:
+            list[FoundryModelInfo]: List of catalog models.
+        """
+        if self._catalog_list is None:
+            self._catalog_list = [
+                FoundryModelInfo.from_list_response(model) for model in self.httpx_client.get("/foundry/list")
+            ]
+        return self._catalog_list
+
+    def _get_catalog_dict(self) -> dict[str, FoundryModelInfo]:
+        """
+        Get a dictionary of available models. Keyed by model ID and alias. Alias points to the most preferred model.
+
+        Returns:
+            dict[str, FoundryModelInfo]: Dictionary of catalog models.
+        """
+        if self._catalog_dict is not None:
+            return self._catalog_dict
+
+        catalog_models = self.list_catalog_models()
+        self._catalog_dict = {model.id: model for model in catalog_models}
+        alias_candidates = {}
+
+        # Group models by alias
+        for model in catalog_models:
+            alias_candidates.setdefault(model.alias, []).append(model)
+
+        # Define the preferred order of execution providers
+        preferred_order = [
+            ExecutionProvider.QNN,
+            ExecutionProvider.CUDA,
+            ExecutionProvider.CPU,
+            ExecutionProvider.WEBGPU,
+        ]
+        if platform.system() != "Windows":
+            # Adjust order for non-Windows platforms
+            preferred_order.remove(ExecutionProvider.CPU)
+            preferred_order.append(ExecutionProvider.CPU)
+
+        priority_map = {provider: index for index, provider in enumerate(preferred_order)}
+
+        # Choose the preferred model for each alias
+        for alias, candidates in alias_candidates.items():
+            self._catalog_dict[alias] = min(candidates, key=lambda model: priority_map.get(model.runtime, float("inf")))
+
+        return self._catalog_dict
+
+    def refresh_catalog(self):
+        """Refresh the catalog."""
+        self._catalog_list = None
+        self._catalog_dict = None
+
+    def get_model_info(self, alias_or_model_id: str, raise_on_not_found: bool = False) -> FoundryModelInfo | None:
+        """
+        Get the model information by alias or ID.
+
+        Args:
+            alias_or_model_id (str): Alias or Model ID. If it is an alias, the most preferred model will be returned.
+            raise_on_not_found (bool): If True, raise an error if the model is not found. Default is False.
+
+        Returns:
+            FoundryModelInfo | None: Model information or None if not found.
+
+        Raises:
+            ValueError: If the model is not found and raise_on_not_found is True.
+        """
+        model_info = self._get_catalog_dict().get(alias_or_model_id)
+        if model_info is None and raise_on_not_found:
+            raise ValueError(f"Model {alias_or_model_id} not found in the catalog.")
+        return model_info
+
+    # Cache management api
+    def get_cache_location(self):
+        """
+        Get the cache location.
+
+        Returns:
+            str: Path to the cache location.
+        """
+        return self.httpx_client.get("/openai/status")["modelDirPath"]
+
+    def _fetch_model_infos(self, model_ids: list[str]) -> list[FoundryModelInfo]:
+        """
+        Fetch model information for a list of model IDs.
+
+        Args:
+            model_ids (list[str]): List of model IDs.
+
+        Returns:
+            list[FoundryModelInfo]: List of model information.
+        """
+        model_infos = []
+        for model_id in model_ids:
+            if (model_info := self.get_model_info(model_id)) is not None:
+                model_infos.append(model_info)
+            else:
+                logger.debug("Model %s not found in the catalog.", model_id)
+        return model_infos
+
+    def list_cached_models(self) -> list[FoundryModelInfo]:
+        """
+        Get a list of cached models.
+
+        Returns:
+            list[FoundryModelInfo]: List of models downloaded to the cache.
+        """
+        return self._fetch_model_infos(self.httpx_client.get("/openai/models"))
+
+    # Model management api
+    def download_model(self, alias_or_model_id: str, token: str | None = None, force: bool = False) -> FoundryModelInfo:
+        """
+        Download a model.
+
+        Args:
+            alias_or_model_id (str): Alias or Model ID. If it is an alias, the most preferred model will be downloaded.
+            token (str | None): Optional token for authentication.
+            force (bool): If True, force download the model even if it is already downloaded.
+
+        Returns:
+            FoundryModelInfo: Model information.
+
+        Raises:
+            RuntimeError: If the model download fails.
+        """
+        model_info = self.get_model_info(alias_or_model_id, raise_on_not_found=True)
+        if model_info in self.list_cached_models() and not force:
+            logger.info(
+                "Model with alias '%s' and ID '%s' is already downloaded. Use force=True to download it again.",
+                model_info.alias,
+                model_info.id,
+            )
+            return model_info
+        logger.info("Downloading model with alias '%s' and ID '%s'...", model_info.alias, model_info.id)
+        response_body = self.httpx_client.post_with_progress(
+            "/openai/download",
+            body={
+                "model": model_info.to_download_body(),
+                "token": token,
+                "IgnorePipeReport": True,
+            },
+        )
+        if not response_body.get("success", False):
+            raise RuntimeError(
+                f"Failed to download model with error: {response_body.get('errorMessage', 'Unknown error')}"
+            )
+        return model_info
+
+    def load_model(self, alias_or_model_id: str, ttl: int = 600) -> FoundryModelInfo:
+        """
+        Load a model.
+
+        Args:
+            alias_or_model_id (str): Alias or Model ID. If it is an alias, the most preferred model will be loaded.
+            ttl (int): Time to live for the model in seconds. Default is 600 seconds (10 minutes).
+
+        Returns:
+            FoundryModelInfo: Model information.
+
+        Raises:
+            ValueError: If the model is not in the catalog or has not been downloaded yet.
+        """
+        model_info = self.get_model_info(alias_or_model_id, raise_on_not_found=True)
+        logger.info("Loading model with alias '%s' and ID '%s'...", model_info.alias, model_info.id)
+        query_params = {"ttl": ttl}
+        if model_info.runtime in {ExecutionProvider.WEBGPU, ExecutionProvider.CUDA}:
+            # these models might have empty ep or dml ep in the genai config
+            # use cuda if available, otherwise use the model's runtime
+            has_cuda_support = any(mi.runtime == ExecutionProvider.CUDA for mi in self.list_catalog_models())
+            query_params["ep"] = (
+                ExecutionProvider.CUDA.get_alias() if has_cuda_support else model_info.runtime.get_alias()
+            )
+        try:
+            self.httpx_client.get(f"/openai/load/{model_info.id}", query_params=query_params)
+        except HttpResponseError as e:
+            if "No OpenAIService provider found for modelName" in str(e):
+                raise ValueError(
+                    f"Model {alias_or_model_id} has not been downloaded yet. Please download it first."
+                ) from None
+            raise
+        return model_info
+
+    def unload_model(self, alias_or_model_id: str, force: bool = False):
+        """
+        Unload a model.
+
+        Args:
+            alias_or_model_id (str): Alias or Model ID.
+            force (bool): If True, force unload a model with TTL.
+        """
+        model_info = self.get_model_info(alias_or_model_id, raise_on_not_found=True)
+        if model_info not in self.list_loaded_models():
+            # safest since unload fails if model is not downloaded, easier to check if loaded
+            logger.info(
+                "Model with alias '%s' and ID '%s' is not loaded. No need to unload.", model_info.alias, model_info.id
+            )
+            return
+        logger.info("Unloading model with alias '%s' and ID '%s'...", model_info.alias, model_info.id)
+        self.httpx_client.get(f"/openai/unload/{model_info.id}", query_params={"force": force})
+
+    def list_loaded_models(self) -> list[FoundryModelInfo]:
+        """
+        Get a list of loaded models.
+
+        Returns:
+            list[FoundryModelInfo]: List of loaded models.
+        """
+        return self._fetch_model_infos(self.httpx_client.get("/openai/loadedmodels"))

foundry_local/client.py

@@ -0,0 +1,117 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+# --------------------------------------------------------------------------
+from __future__ import annotations
+
+import json
+import logging
+import re
+
+import httpx
+from tqdm import tqdm
+
+logger = logging.getLogger(__name__)
+
+
+class HttpResponseError(Exception):
+    pass
+
+
+class HttpxClient:
+    """
+    Client for Foundry Local SDK.
+
+    Attributes:
+        _client (httpx.Client): HTTP client instance.
+    """
+
+    def __init__(self, host: str, timeout: float | httpx.Timeout | None = None) -> None:
+        """
+        Initialize the HttpxClient with the host.
+
+        Args:
+            host (str): Base URL of the host.
+            timeout (float | httpx.Timeout | None): Timeout for the HTTP client.
+        """
+        self._client = httpx.Client(base_url=host, timeout=timeout)
+
+    def _request(self, *args, **kwargs) -> httpx.Response:
+        """
+        Send an HTTP request.
+
+        Args:
+            *args: Positional arguments for the request.
+            **kwargs: Keyword arguments for the request.
+
+        Returns:
+            httpx.Response: HTTP response object.
+
+        Raises:
+            RuntimeError: If an HTTP error or connection error occurs.
+        """
+        try:
+            response = self._client.request(*args, **kwargs)
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            raise HttpResponseError(f"{e.response.status_code} - {e.response.text}") from None
+        except httpx.ConnectError:
+            raise ConnectionError(
+                "Could not connect to Foundry Local! Please check if the Foundry Local service is running and the host"
+                " URL is correct."
+            ) from None
+        return response
+
+    def get(self, path: str, query_params: dict[str, str] | None = None) -> dict | list | None:
+        """
+        Send a GET request to the specified path with optional query parameters.
+
+        Args:
+            path (str): Path for the GET request.
+            query_params (dict[str, str] | None): Query parameters for the request.
+
+        Returns:
+            dict | list | None: JSON response or None if no content.
+        """
+        response = self._request("GET", path, params=query_params)
+        return response.json() if response.text else None
+
+    def post_with_progress(self, path: str, body: dict | None = None) -> dict:
+        """
+        Send a POST request to the specified path with optional request body and show progress.
+
+        Args:
+            path (str): Path for the POST request.
+            body (dict | None): Request body in JSON format.
+
+        Returns:
+            dict: JSON response.
+
+        Raises:
+            ValueError: If the JSON response is invalid.
+        """
+        with self._client.stream("POST", path, json=body, timeout=None) as response:
+            progress_bar = None
+            prev_percent = 0.0
+            if logger.isEnabledFor(logging.INFO):
+                progress_bar = tqdm(total=100.0)
+            final_json = ""
+            for line in response.iter_lines():
+                if final_json or line.startswith("{"):
+                    final_json += line
+                    continue
+                if not progress_bar:
+                    continue
+                if match := re.search(r"(\d+(?:\.\d+)?)%", line):
+                    percent = min(float(match.group(1)), 100.0)
+                    delta = percent - prev_percent
+                    if delta > 0:
+                        progress_bar.update(delta)
+                        prev_percent = percent
+            if progress_bar:
+                progress_bar.close()
+
+            if not final_json.endswith("}"):
+                raise ValueError(f"Invalid JSON response: {final_json}")
+
+            return json.loads(final_json)

foundry_local/logging.py

@@ -0,0 +1,92 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+# --------------------------------------------------------------------------
+import logging
+
+
+def get_logger():
+    """
+    Get the logger for the sdk.
+
+    Returns:
+        logging.Logger: Logger instance for the module.
+    """
+    return logging.getLogger(__name__.split(".", maxsplit=1)[0])
+
+
+def set_verbosity(verbose):
+    """
+    Set the verbosity level for the logger.
+
+    Args:
+        verbose (int): Verbosity level (e.g., logging.INFO, logging.DEBUG).
+    """
+    get_logger().setLevel(verbose)
+
+
+def set_verbosity_info():
+    """Set the verbosity level to INFO."""
+    set_verbosity(logging.INFO)
+
+
+def set_verbosity_warning():
+    """Set the verbosity level to WARNING."""
+    set_verbosity(logging.WARNING)
+
+
+def set_verbosity_debug():
+    """Set the verbosity level to DEBUG."""
+    set_verbosity(logging.DEBUG)
+
+
+def set_verbosity_error():
+    """Set the verbosity level to ERROR."""
+    set_verbosity(logging.ERROR)
+
+
+def set_verbosity_critical():
+    """Set the verbosity level to CRITICAL."""
+    set_verbosity(logging.CRITICAL)
+
+
+def get_verbosity() -> int:
+    """
+    Get the current verbosity level of the logger.
+
+    Returns:
+        int: Verbosity level as an integer.
+    """
+    return get_logger().getEffectiveLevel()
+
+
+def get_logger_level(level):
+    """
+    Get Python logging level for the integer level.
+
+    Args:
+        level (int): Verbosity level (0: DEBUG, 1: INFO, 2: WARNING, 3: ERROR, 4: CRITICAL).
+
+    Returns:
+        int: Corresponding Python logging level.
+
+    Raises:
+        ValueError: If the level is invalid.
+    """
+    level_map = {0: logging.DEBUG, 1: logging.INFO, 2: logging.WARNING, 3: logging.ERROR, 4: logging.CRITICAL}
+    # check if level is valid
+    if level not in level_map:
+        raise ValueError(f"Invalid level {level}, should be one of {list(level_map.keys())}")
+
+    return level_map[level]
+
+
+def set_default_logger_severity(level):
+    """
+    Set the default log level for the logger.
+
+    Args:
+        level (int): Verbosity level (0: DEBUG, 1: INFO, 2: WARNING, 3: ERROR, 4: CRITICAL).
+    """
+    # set logger level
+    set_verbosity(get_logger_level(level))

foundry_local/models.py

@@ -0,0 +1,144 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+# --------------------------------------------------------------------------
+from __future__ import annotations
+
+import sys
+
+from pydantic import BaseModel, Field
+
+if sys.version_info >= (3, 11):
+    from enum import StrEnum
+
+else:
+    from enum import Enum
+
+    class StrEnum(str, Enum):
+        def __str__(self) -> str:
+            return self.value
+
+
+# ruff: noqa: N815
+
+
+class DeviceType(StrEnum):
+    """Enumeration of devices supported by the model."""
+
+    CPU = "CPU"
+    GPU = "GPU"
+    NPU = "NPU"
+
+
+class ExecutionProvider(StrEnum):
+    """Enumeration of execution providers supported by the model."""
+
+    CPU = "CPUExecutionProvider"
+    WEBGPU = "WebGpuExecutionProvider"
+    CUDA = "CUDAExecutionProvider"
+    QNN = "QNNExecutionProvider"
+
+    def get_alias(self) -> str:
+        """
+        Get the alias for the execution provider.
+
+        Returns:
+            str: Alias of the execution provider.
+        """
+        return self.value.replace("ExecutionProvider", "").lower()
+
+
+class ModelRuntime(BaseModel):
+    """Model runtime information."""
+
+    deviceType: DeviceType = Field(..., description="Device type supported by the model")
+    executionProvider: ExecutionProvider = Field(
+        ...,
+        description="Execution provider supported by the model",
+    )
+
+
+class FoundryListResponseModel(BaseModel):
+    """Response model for listing models."""
+
+    name: str = Field(..., description="Name of the model")
+    displayName: str = Field(..., description="Display name of the model")
+    modelType: str = Field(..., description="Type of the model")
+    providerType: str = Field(..., description="Provider type of the model")
+    uri: str = Field(..., description="URI of the model")
+    version: str = Field(..., description="Version of the model")
+    promptTemplate: dict = Field(..., description="Prompt template for the model")
+    publisher: str = Field(..., description="Publisher of the model")
+    task: str = Field(..., description="Task of the model")
+    runtime: ModelRuntime = Field(..., description="Runtime information of the model")
+    fileSizeMb: int = Field(..., description="File size of the model in MB")
+    modelSettings: dict = Field(..., description="Model settings")
+    alias: str = Field(..., description="Alias name of the model")
+    supportsToolCalling: bool = Field(..., description="Whether the model supports tool calling")
+    license: str = Field(..., description="License of the model")
+    licenseDescription: str = Field(..., description="License description of the model")
+    parentModelUri: str = Field(..., description="Parent model URI of the model")
+
+
+class FoundryModelInfo(BaseModel):
+    """Model information."""
+
+    alias: str = Field(..., description="Alias of the model")
+    id: str = Field(..., description="Unique identifier of the model")
+    version: str = Field(..., description="Version of the model")
+    runtime: ExecutionProvider = Field(..., description="Execution provider of the model")
+    uri: str = Field(..., description="URI of the model")
+    model_size: int = Field(..., description="Size of the model on disk in MB")
+    prompt_template: dict = Field(..., description="Prompt template for the model")
+    provider: str = Field(..., description="Provider of the model")
+    publisher: str = Field(..., description="Publisher of the model")
+    license: str = Field(..., description="License of the model")
+    task: str = Field(..., description="Task of the model")
+
+    def __repr__(self) -> str:
+        return (
+            f"FoundryModelInfo(alias={self.alias}, id={self.id}, runtime={self.runtime.get_alias()},"
+            f" model_size={self.model_size} MB, license={self.license})"
+        )
+
+    @classmethod
+    def from_list_response(cls, response: dict | FoundryListResponseModel) -> FoundryModelInfo:
+        """
+        Create a FoundryModelInfo object from a FoundryListResponseModel object.
+
+        Args:
+            response (dict | FoundryListResponseModel): Response data.
+
+        Returns:
+            FoundryModelInfo: Instance of FoundryModelInfo.
+        """
+        if isinstance(response, dict):
+            response = FoundryListResponseModel.model_validate(response)
+        return cls(
+            alias=response.alias,
+            id=response.name,
+            version=response.version,
+            runtime=response.runtime.executionProvider,
+            uri=response.uri,
+            model_size=response.fileSizeMb,
+            prompt_template=response.promptTemplate,
+            provider=response.providerType,
+            publisher=response.publisher,
+            license=response.license,
+            task=response.task,
+        )
+
+    def to_download_body(self) -> dict:
+        """
+        Convert the FoundryModelInfo object to a dictionary for download.
+
+        Returns:
+            dict: Dictionary representation for download.
+        """
+        return {
+            "Name": self.id,
+            "Uri": self.uri,
+            "Publisher": self.publisher,
+            "ProviderType": f"{self.provider}Local" if self.provider == "AzureFoundry" else self.provider,
+            "PromptTemplate": self.prompt_template,
+        }

foundry_local/service.py

@@ -0,0 +1,61 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+# --------------------------------------------------------------------------
+from __future__ import annotations
+
+import logging
+import re
+import shutil
+import subprocess
+import time
+
+logger = logging.getLogger(__name__)
+
+
+def assert_foundry_installed():
+    """
+    Assert that Foundry is installed.
+
+    Raises:
+        RuntimeError: If Foundry is not installed or not on PATH.
+    """
+    if shutil.which("foundry") is None:
+        raise RuntimeError("Foundry is not installed or not on PATH!")
+
+
+def get_service_uri() -> str | None:
+    """
+    Get the service URI if the service is running.
+
+    Returns:
+        str | None: URI of the running Foundry service, or None if not running.
+    """
+    with subprocess.Popen(["foundry", "service", "status"], stdout=subprocess.PIPE, stderr=subprocess.PIPE) as proc:
+        stdout, _ = proc.communicate()
+        match = re.search(r"http://(?:[a-zA-Z0-9.-]+|\d{1,3}(\.\d{1,3}){3}):\d+", stdout.decode())
+        if match:
+            return match.group(0)
+        return None
+
+
+def start_service() -> str | None:
+    """
+    Start the Foundry service.
+
+    Returns:
+        str | None: URI of the started Foundry service, or None if it failed to start.
+    """
+    if (service_url := get_service_uri()) is not None:
+        logger.info("Foundry service is already running at %s", service_url)
+        return service_url
+
+    with subprocess.Popen(["foundry", "service", "start"]):
+        # not checking the process output since it never finishes communication
+        for _ in range(10):
+            if (service_url := get_service_uri()) is not None:
+                logger.info("Foundry service started successfully at %s", service_url)
+                return service_url
+            time.sleep(0.1)
+        logger.warning("Foundry service did not start within the expected time. May not be running.")
+        return None

foundry_local_sdk-0.3.0.dist-info/METADATA

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: foundry-local-sdk
+Version: 0.3.0
+Summary: Foundry Local Manager Python SDK: Control-plane SDK for Foundry Local.
+Author: Microsoft Corporation
+Author-email: foundrylocaldevs@microsoft.com
+License: MIT License
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: httpx
+Requires-Dist: pydantic
+Requires-Dist: tqdm
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Foundry Local Python SDK
+The Foundry Local SDK simplifies AI model management in local environments by providing control-plane operations separate from data-plane inferencing code.
+
+## Prerequisites
+Foundry Local must be installed and findable in your PATH.
+
+## Getting Started
+```
+pip install foundry-local-sdk
+```
+
+## Usage
+
+The SDK provides a simple interface to interact with the Foundry Local API. You can use it to manage models, check the status of the service, and make requests to the models.
+
+### Bootstrapping
+
+The SDK can *bootstrap* Foundry Local, which will initiate the following sequence:
+
+1. Start the Foundry Local service, if it is not already running.
+1. Automatically detect the hardware and software requirements for the model.
+1. Download the highest-performance model for the detected hardware, if it is not already downloaded.
+1. Load the model into memory.
+
+To use the SDK with bootstrapping, you can use the following code:
+
+```python
+from foundry_local import FoundryLocalManager
+
+# Provide the alias of the model you want to use
+# The alias is a string that identifies the model in the Foundry Local catalog.
+# The alias can be found in the Foundry Local catalog.
+# For example, "phi-3.5-mini" is the alias for the Phi 3.5 model.
+# Foundry local will automatically download the most suitable model for your hardware.
+alias = "phi-3.5-mini"
+fl_manager = FoundryLocalManager(alias)
+
+# check that the service is running
+print(fl_manager.is_service_running())
+
+# list all available models in the catalog
+print(fl_manager.list_catalog_models())
+
+# list all downloaded models
+print(fl_manager.list_cached_models())
+
+# get information on the selected model
+model_info = fl_manager.get_model_info(alias)
+print(model_info)
+```
+
+Alternatively, you can use the `FoundryLocalManager` class to manage the service and models manually. This is useful if you want to control the service and models without bootstrapping. For example, you want to present to the end user what is happening in the background.
+
+```python
+from foundry_local import FoundryLocalManager
+
+alias = "phi-3.5-mini"
+fl_manager = FoundryLocalManager()
+
+# start the service
+fl_manager.start_service()
+
+# download the model
+fl_manager.download_model(alias)
+
+# load the model
+model_info = fl_manager.load_model(alias)
+print(model_info)
+```
+
+Use the foundry local endpoint with an OpenAI compatible API client. For example, using the `openai` package:
+
+```python
+import openai
+from foundry_local import FoundryLocalManager
+
+# By using an alias, the most suitable model will be downloaded 
+# to your end-user's device.
+alias = "phi-3.5-mini"
+
+# Create a FoundryLocalManager instance. This will start the Foundry 
+# Local service if it is not already running and load the specified model.
+manager = FoundryLocalManager(alias)
+
+# The remaining code us es the OpenAI Python SDK to interact with the local model.
+
+# Configure the client to use the local Foundry service
+client = openai.OpenAI(
+    base_url=manager.endpoint,
+    api_key=manager.api_key  # API key is not required for local usage
+)
+
+# Set the model to use and generate a streaming response
+stream = client.chat.completions.create(
+    model=manager.get_model_info(alias).id,
+    messages=[{"role": "user", "content": "What is the golden ratio?"}],
+    stream=True
+)
+
+# Print the streaming response
+for chunk in stream:
+    if chunk.choices[0].delta.content is not None:
+        print(chunk.choices[0].delta.content, end="", flush=True)
+```

foundry_local_sdk-0.3.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+foundry_local/__init__.py,sha256=q83bJ8Aw6Yg1Pfy8KwXPglkJvEOkR66mJN8DPF1ulYQ,736
+foundry_local/api.py,sha256=A1L63_duWGCRjFVzO76KRdpGCCyfvp4Lz9BLCBPACas,12699
+foundry_local/client.py,sha256=vKKhshuTJOOyHLlZ8JdFRIm5pUl3fpEtMxamMu9kUwU,4065
+foundry_local/logging.py,sha256=k4_qHXM0bitU_5DQZyGDTogWGVXX3FOd7z0zlC8TezM,2403
+foundry_local/models.py,sha256=wAam90hp_PYFreYh_a0QDGCZ9GoMbKfeSnMBoFpfgwI,5487
+foundry_local/service.py,sha256=vo7mYL1Nilj68rPGKaopdeazQQ9gk-wS1rDbZjqqc9Q,2104
+foundry_local_sdk-0.3.0.dist-info/licenses/LICENSE.txt,sha256=wlDWJ48LR6ZDn7dZKwi1ilXrn1NapJodtjIRw_mCtnQ,1094
+foundry_local_sdk-0.3.0.dist-info/METADATA,sha256=gdyyhnVtQEOxD6sIS-7ulVzbCbY9RN0TuQtBTx6e0AM,4960
+foundry_local_sdk-0.3.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+foundry_local_sdk-0.3.0.dist-info/top_level.txt,sha256=TE2fqMfN2Txs1Wltmv8-tu-Y6C4E0-0fg0zwO8w69QQ,14
+foundry_local_sdk-0.3.0.dist-info/RECORD,,

foundry_local_sdk-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.7.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

foundry_local_sdk-0.3.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Microsoft Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

foundry_local_sdk-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+foundry_local