llama-stack 0.0.42__py3-none-any.whl → 0.3.4__py3-none-any.whl

llama_stack/cli/model/safety_models.py

@@ -1,52 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the terms described in the LICENSE file in
-# the root directory of this source tree.
-
-from typing import Any, Dict, Optional
-
-from pydantic import BaseModel, ConfigDict, Field
-
-from llama_models.datatypes import *  # noqa: F403
-from llama_models.sku_list import LlamaDownloadInfo
-
-
-class PromptGuardModel(BaseModel):
-    """Make a 'fake' Model-like object for Prompt Guard. Eventually this will be removed."""
-
-    model_id: str = "Prompt-Guard-86M"
-    description: str = (
-        "Prompt Guard. NOTE: this model will not be provided via `llama` CLI soon."
-    )
-    is_featured: bool = False
-    huggingface_repo: str = "meta-llama/Prompt-Guard-86M"
-    max_seq_length: int = 2048
-    is_instruct_model: bool = False
-    quantization_format: CheckpointQuantizationFormat = (
-        CheckpointQuantizationFormat.bf16
-    )
-    arch_args: Dict[str, Any] = Field(default_factory=dict)
-    recommended_sampling_params: Optional[SamplingParams] = None
-
-    def descriptor(self) -> str:
-        return self.model_id
-
-    model_config = ConfigDict(protected_namespaces=())
-
-
-def prompt_guard_model_sku():
-    return PromptGuardModel()
-
-
-def prompt_guard_download_info():
-    return LlamaDownloadInfo(
-        folder="Prompt-Guard",
-        files=[
-            "model.safetensors",
-            "special_tokens_map.json",
-            "tokenizer.json",
-            "tokenizer_config.json",
-        ],
-        pth_size=1,
-    )

llama_stack/cli/stack/build.py

@@ -1,299 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the terms described in the LICENSE file in
-# the root directory of this source tree.
-
-import argparse
-
-from llama_stack.cli.subcommand import Subcommand
-from llama_stack.distribution.datatypes import *  # noqa: F403
-import os
-from functools import lru_cache
-from pathlib import Path
-
-TEMPLATES_PATH = (
-    Path(os.path.relpath(__file__)).parent.parent.parent / "distribution" / "templates"
-)
-
-
-@lru_cache()
-def available_templates_specs() -> List[BuildConfig]:
-    import yaml
-
-    template_specs = []
-    for p in TEMPLATES_PATH.rglob("*build.yaml"):
-        with open(p, "r") as f:
-            build_config = BuildConfig(**yaml.safe_load(f))
-            template_specs.append(build_config)
-
-    return template_specs
-
-
-class StackBuild(Subcommand):
-    def __init__(self, subparsers: argparse._SubParsersAction):
-        super().__init__()
-        self.parser = subparsers.add_parser(
-            "build",
-            prog="llama stack build",
-            description="Build a Llama stack container",
-            formatter_class=argparse.RawTextHelpFormatter,
-        )
-        self._add_arguments()
-        self.parser.set_defaults(func=self._run_stack_build_command)
-
-    def _add_arguments(self):
-        self.parser.add_argument(
-            "--config",
-            type=str,
-            default=None,
-            help="Path to a config file to use for the build. You can find example configs in llama_stack/distribution/example_configs. If this argument is not provided, you will be prompted to enter information interactively",
-        )
-
-        self.parser.add_argument(
-            "--template",
-            type=str,
-            default=None,
-            help="Name of the example template config to use for build. You may use `llama stack build --list-templates` to check out the available templates",
-        )
-
-        self.parser.add_argument(
-            "--list-templates",
-            type=bool,
-            default=False,
-            action=argparse.BooleanOptionalAction,
-            help="Show the available templates for building a Llama Stack distribution",
-        )
-
-        self.parser.add_argument(
-            "--name",
-            type=str,
-            help="Name of the Llama Stack build to override from template config. This name will be used as paths to store configuration files, build conda environments/docker images. If not specified, will use the name from the template config. ",
-        )
-
-        self.parser.add_argument(
-            "--image-type",
-            type=str,
-            help="Image Type to use for the build. This can be either conda or docker. If not specified, will use the image type from the template config.",
-            choices=["conda", "docker"],
-        )
-
-    def _get_build_config_from_name(self, args: argparse.Namespace) -> Optional[Path]:
-        if os.getenv("CONDA_PREFIX", ""):
-            conda_dir = (
-                Path(os.getenv("CONDA_PREFIX")).parent / f"llamastack-{args.name}"
-            )
-        else:
-            cprint(
-                "Cannot find CONDA_PREFIX. Trying default conda path ~/.conda/envs...",
-                color="green",
-            )
-            conda_dir = (
-                Path(os.path.expanduser("~/.conda/envs")) / f"llamastack-{args.name}"
-            )
-        build_config_file = Path(conda_dir) / f"{args.name}-build.yaml"
-        if build_config_file.exists():
-            return build_config_file
-
-        return None
-
-    def _run_stack_build_command_from_build_config(
-        self, build_config: BuildConfig
-    ) -> None:
-        import json
-        import os
-
-        import yaml
-
-        from llama_stack.distribution.build import build_image, ImageType
-        from llama_stack.distribution.utils.config_dirs import DISTRIBS_BASE_DIR
-        from llama_stack.distribution.utils.serialize import EnumEncoder
-        from termcolor import cprint
-
-        # save build.yaml spec for building same distribution again
-        if build_config.image_type == ImageType.docker.value:
-            # docker needs build file to be in the llama-stack repo dir to be able to copy over to the image
-            llama_stack_path = Path(
-                os.path.abspath(__file__)
-            ).parent.parent.parent.parent
-            build_dir = llama_stack_path / "tmp/configs/"
-        else:
-            build_dir = DISTRIBS_BASE_DIR / f"llamastack-{build_config.name}"
-
-        os.makedirs(build_dir, exist_ok=True)
-        build_file_path = build_dir / f"{build_config.name}-build.yaml"
-
-        with open(build_file_path, "w") as f:
-            to_write = json.loads(json.dumps(build_config.dict(), cls=EnumEncoder))
-            f.write(yaml.dump(to_write, sort_keys=False))
-
-        return_code = build_image(build_config, build_file_path)
-        if return_code != 0:
-            return
-
-        configure_name = (
-            build_config.name
-            if build_config.image_type == "conda"
-            else (f"llamastack-{build_config.name}")
-        )
-        if build_config.image_type == "conda":
-            cprint(
-                f"You can now run `llama stack configure {configure_name}`",
-                color="green",
-            )
-        else:
-            cprint(
-                f"You can now run `llama stack run {build_config.name}`",
-                color="green",
-            )
-
-    def _run_template_list_cmd(self, args: argparse.Namespace) -> None:
-        import json
-
-        from llama_stack.cli.table import print_table
-
-        # eventually, this should query a registry at llama.meta.com/llamastack/distributions
-        headers = [
-            "Template Name",
-            "Providers",
-            "Description",
-        ]
-
-        rows = []
-        for spec in available_templates_specs():
-            rows.append(
-                [
-                    spec.name,
-                    json.dumps(spec.distribution_spec.providers, indent=2),
-                    spec.distribution_spec.description,
-                ]
-            )
-        print_table(
-            rows,
-            headers,
-            separate_rows=True,
-        )
-
-    def _run_stack_build_command(self, args: argparse.Namespace) -> None:
-        import textwrap
-
-        import yaml
-        from llama_stack.distribution.distribution import get_provider_registry
-        from prompt_toolkit import prompt
-        from prompt_toolkit.completion import WordCompleter
-        from prompt_toolkit.validation import Validator
-        from termcolor import cprint
-
-        if args.list_templates:
-            self._run_template_list_cmd(args)
-            return
-
-        if args.template:
-            if not args.name:
-                self.parser.error(
-                    "You must specify a name for the build using --name when using a template"
-                )
-                return
-            build_path = TEMPLATES_PATH / f"{args.template}-build.yaml"
-            if not build_path.exists():
-                self.parser.error(
-                    f"Could not find template {args.template}. Please run `llama stack build --list-templates` to check out the available templates"
-                )
-                return
-            with open(build_path, "r") as f:
-                build_config = BuildConfig(**yaml.safe_load(f))
-                build_config.name = args.name
-                if args.image_type:
-                    build_config.image_type = args.image_type
-                self._run_stack_build_command_from_build_config(build_config)
-
-            return
-
-        # try to see if we can find a pre-existing build config file through name
-        if args.name:
-            maybe_build_config = self._get_build_config_from_name(args)
-            if maybe_build_config:
-                cprint(
-                    f"Building from existing build config for {args.name} in {str(maybe_build_config)}...",
-                    "green",
-                )
-                with open(maybe_build_config, "r") as f:
-                    build_config = BuildConfig(**yaml.safe_load(f))
-                    self._run_stack_build_command_from_build_config(build_config)
-                    return
-
-        if not args.config and not args.template:
-            if not args.name:
-                name = prompt(
-                    "> Enter a name for your Llama Stack (e.g. my-local-stack): ",
-                    validator=Validator.from_callable(
-                        lambda x: len(x) > 0,
-                        error_message="Name cannot be empty, please enter a name",
-                    ),
-                )
-            else:
-                name = args.name
-
-            image_type = prompt(
-                "> Enter the image type you want your Llama Stack to be built as (docker or conda): ",
-                validator=Validator.from_callable(
-                    lambda x: x in ["docker", "conda"],
-                    error_message="Invalid image type, please enter conda or docker",
-                ),
-                default="conda",
-            )
-
-            cprint(
-                textwrap.dedent(
-                    """
-                Llama Stack is composed of several APIs working together. Let's select
-                the provider types (implementations) you want to use for these APIs.
-                """,
-                ),
-                color="green",
-            )
-
-            print("Tip: use <TAB> to see options for the providers.\n")
-
-            providers = dict()
-            for api, providers_for_api in get_provider_registry().items():
-                available_providers = [
-                    x
-                    for x in providers_for_api.keys()
-                    if x not in ("remote", "remote::sample")
-                ]
-                api_provider = prompt(
-                    "> Enter provider for API {}: ".format(api.value),
-                    completer=WordCompleter(available_providers),
-                    complete_while_typing=True,
-                    validator=Validator.from_callable(
-                        lambda x: x in available_providers,
-                        error_message="Invalid provider, use <TAB> to see options",
-                    ),
-                )
-
-                providers[api.value] = api_provider
-
-            description = prompt(
-                "\n > (Optional) Enter a short description for your Llama Stack: ",
-                default="",
-            )
-
-            distribution_spec = DistributionSpec(
-                providers=providers,
-                description=description,
-            )
-
-            build_config = BuildConfig(
-                name=name, image_type=image_type, distribution_spec=distribution_spec
-            )
-            self._run_stack_build_command_from_build_config(build_config)
-            return
-
-        with open(args.config, "r") as f:
-            try:
-                build_config = BuildConfig(**yaml.safe_load(f))
-            except Exception as e:
-                self.parser.error(f"Could not parse config file {args.config}: {e}")
-                return
-            self._run_stack_build_command_from_build_config(build_config)

llama_stack/cli/stack/configure.py

@@ -1,178 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the terms described in the LICENSE file in
-# the root directory of this source tree.
-
-import argparse
-
-from llama_stack.cli.subcommand import Subcommand
-from llama_stack.distribution.utils.config_dirs import BUILDS_BASE_DIR
-from llama_stack.distribution.datatypes import *  # noqa: F403
-
-
-class StackConfigure(Subcommand):
-    """Llama cli for configuring llama toolchain configs"""
-
-    def __init__(self, subparsers: argparse._SubParsersAction):
-        super().__init__()
-        self.parser = subparsers.add_parser(
-            "configure",
-            prog="llama stack configure",
-            description="configure a llama stack distribution",
-            formatter_class=argparse.RawTextHelpFormatter,
-        )
-        self._add_arguments()
-        self.parser.set_defaults(func=self._run_stack_configure_cmd)
-
-    def _add_arguments(self):
-        self.parser.add_argument(
-            "config",
-            type=str,
-            help="Path to the build config file (e.g. ~/.llama/builds/<image_type>/<name>-build.yaml). For docker, this could also be the name of the docker image. ",
-        )
-
-        self.parser.add_argument(
-            "--output-dir",
-            type=str,
-            help="Path to the output directory to store generated run.yaml config file. If not specified, will use ~/.llama/build/<image_type>/<name>-run.yaml",
-        )
-
-    def _run_stack_configure_cmd(self, args: argparse.Namespace) -> None:
-        import json
-        import os
-        import subprocess
-        from pathlib import Path
-
-        import pkg_resources
-
-        import yaml
-        from termcolor import cprint
-
-        from llama_stack.distribution.build import ImageType
-        from llama_stack.distribution.utils.exec import run_with_pty
-
-        docker_image = None
-
-        build_config_file = Path(args.config)
-
-        if build_config_file.exists():
-            with open(build_config_file, "r") as f:
-                build_config = BuildConfig(**yaml.safe_load(f))
-                self._configure_llama_distribution(build_config, args.output_dir)
-            return
-
-        # if we get here, we need to try to find the conda build config file
-        cprint(
-            f"Could not find {build_config_file}. Trying conda build name instead...",
-            color="green",
-        )
-
-        conda_dir = (
-            Path(os.path.expanduser("~/.conda/envs")) / f"llamastack-{args.config}"
-        )
-        output = subprocess.check_output(["bash", "-c", "conda info --json"])
-        conda_envs = json.loads(output.decode("utf-8"))["envs"]
-
-        for x in conda_envs:
-            if x.endswith(f"/llamastack-{args.config}"):
-                conda_dir = Path(x)
-                break
-
-        build_config_file = Path(conda_dir) / f"{args.config}-build.yaml"
-
-        if build_config_file.exists():
-            with open(build_config_file, "r") as f:
-                build_config = BuildConfig(**yaml.safe_load(f))
-
-            self._configure_llama_distribution(build_config, args.output_dir)
-            return
-
-        # if we get here, we need to try to find the docker image
-        cprint(
-            f"Could not find {build_config_file}. Trying docker image name instead...",
-            color="green",
-        )
-        docker_image = args.config
-        builds_dir = BUILDS_BASE_DIR / ImageType.docker.value
-        if args.output_dir:
-            builds_dir = Path(output_dir)
-        os.makedirs(builds_dir, exist_ok=True)
-
-        script = pkg_resources.resource_filename(
-            "llama_stack", "distribution/configure_container.sh"
-        )
-        script_args = [script, docker_image, str(builds_dir)]
-
-        return_code = run_with_pty(script_args)
-
-        # we have regenerated the build config file with script, now check if it exists
-        if return_code != 0:
-            self.parser.error(
-                f"Failed to configure container {docker_image} with return code {return_code}. Please run `llama stack build` first. "
-            )
-            return
-
-        return
-
-    def _configure_llama_distribution(
-        self,
-        build_config: BuildConfig,
-        output_dir: Optional[str] = None,
-    ):
-        import json
-        import os
-        from pathlib import Path
-
-        import yaml
-        from termcolor import cprint
-
-        from llama_stack.distribution.configure import (
-            configure_api_providers,
-            parse_and_maybe_upgrade_config,
-        )
-        from llama_stack.distribution.utils.serialize import EnumEncoder
-
-        builds_dir = BUILDS_BASE_DIR / build_config.image_type
-        if output_dir:
-            builds_dir = Path(output_dir)
-        os.makedirs(builds_dir, exist_ok=True)
-        image_name = build_config.name.replace("::", "-")
-        run_config_file = builds_dir / f"{image_name}-run.yaml"
-
-        if run_config_file.exists():
-            cprint(
-                f"Configuration already exists at `{str(run_config_file)}`. Will overwrite...",
-                "yellow",
-                attrs=["bold"],
-            )
-            config_dict = yaml.safe_load(run_config_file.read_text())
-            config = parse_and_maybe_upgrade_config(config_dict)
-        else:
-            config = StackRunConfig(
-                built_at=datetime.now(),
-                image_name=image_name,
-                apis=list(build_config.distribution_spec.providers.keys()),
-                providers={},
-            )
-
-        config = configure_api_providers(config, build_config.distribution_spec)
-
-        config.docker_image = (
-            image_name if build_config.image_type == "docker" else None
-        )
-        config.conda_env = image_name if build_config.image_type == "conda" else None
-
-        with open(run_config_file, "w") as f:
-            to_write = json.loads(json.dumps(config.dict(), cls=EnumEncoder))
-            f.write(yaml.dump(to_write, sort_keys=False))
-
-        cprint(
-            f"> YAML configuration has been written to `{run_config_file}`.",
-            color="blue",
-        )
-
-        cprint(
-            f"You can now run `llama stack run {image_name} --port PORT`",
-            color="green",
-        )

llama_stack/distribution/build.py

@@ -1,123 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the terms described in the LICENSE file in
-# the root directory of this source tree.
-
-from enum import Enum
-from typing import List, Optional
-
-import pkg_resources
-
-from llama_stack.distribution.utils.exec import run_with_pty
-from pydantic import BaseModel
-
-from termcolor import cprint
-
-from llama_stack.distribution.datatypes import *  # noqa: F403
-from pathlib import Path
-
-from llama_stack.distribution.utils.config_dirs import BUILDS_BASE_DIR
-from llama_stack.distribution.distribution import get_provider_registry
-
-
-# These are the dependencies needed by the distribution server.
-# `llama-stack` is automatically installed by the installation script.
-SERVER_DEPENDENCIES = [
-    "fastapi",
-    "fire",
-    "httpx",
-    "uvicorn",
-]
-
-
-class ImageType(Enum):
-    docker = "docker"
-    conda = "conda"
-
-
-class Dependencies(BaseModel):
-    pip_packages: List[str]
-    docker_image: Optional[str] = None
-
-
-class ApiInput(BaseModel):
-    api: Api
-    provider: str
-
-
-def build_image(build_config: BuildConfig, build_file_path: Path):
-    package_deps = Dependencies(
-        docker_image=build_config.distribution_spec.docker_image or "python:3.10-slim",
-        pip_packages=SERVER_DEPENDENCIES,
-    )
-
-    # extend package dependencies based on providers spec
-    all_providers = get_provider_registry()
-    for (
-        api_str,
-        provider_or_providers,
-    ) in build_config.distribution_spec.providers.items():
-        providers_for_api = all_providers[Api(api_str)]
-
-        providers = (
-            provider_or_providers
-            if isinstance(provider_or_providers, list)
-            else [provider_or_providers]
-        )
-
-        for provider in providers:
-            if provider not in providers_for_api:
-                raise ValueError(
-                    f"Provider `{provider}` is not available for API `{api_str}`"
-                )
-
-            provider_spec = providers_for_api[provider]
-            package_deps.pip_packages.extend(provider_spec.pip_packages)
-            if provider_spec.docker_image:
-                raise ValueError("A stack's dependencies cannot have a docker image")
-
-    special_deps = []
-    deps = []
-    for package in package_deps.pip_packages:
-        if "--no-deps" in package or "--index-url" in package:
-            special_deps.append(package)
-        else:
-            deps.append(package)
-    deps = list(set(deps))
-    special_deps = list(set(special_deps))
-
-    if build_config.image_type == ImageType.docker.value:
-        script = pkg_resources.resource_filename(
-            "llama_stack", "distribution/build_container.sh"
-        )
-        args = [
-            script,
-            build_config.name,
-            package_deps.docker_image,
-            str(build_file_path),
-            str(BUILDS_BASE_DIR / ImageType.docker.value),
-            " ".join(deps),
-        ]
-    else:
-        script = pkg_resources.resource_filename(
-            "llama_stack", "distribution/build_conda_env.sh"
-        )
-        args = [
-            script,
-            build_config.name,
-            str(build_file_path),
-            " ".join(deps),
-        ]
-
-    if special_deps:
-        args.append("#".join(special_deps))
-
-    return_code = run_with_pty(args)
-    if return_code != 0:
-        cprint(
-            f"Failed to build target {build_config.name} with return code {return_code}",
-            color="red",
-        )
-
-    return return_code