llmstudio 0.2.0__tar.gz → 0.2.2__tar.gz

{llmstudio-0.2.0 → llmstudio-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: llmstudio
-Version: 0.2.0
+Version: 0.2.2
 Summary: Prompt Perfection at Your Fingertips
 Home-page: https://llmstudio.ai/
 Author: TensorOps
@@ -8,5 +8,6 @@ Author-email: contact@tensorops.ai
 Project-URL: Source Code, https://github.com/tensoropsai/llmstudio
 Project-URL: Bug Tracker, https://github.com/tensoropsai/llmstudio/issues
 Project-URL: Documentation, https://docs.llmstudio.ai
-Keywords: ml ai llm llmstudio tensorops
+Keywords: ml ai llm llmops openai langchain chatgpt llmstudio tensorops
+Requires-Python: ~=3.9
 License-File: LICENSE

{llmstudio-0.2.0 → llmstudio-0.2.2}/llmstudio/__init__.py

@@ -1,8 +1,7 @@
 name = "version"
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 
 __requirements__ = [
-    # core
     "pydantic",
     "requests",
     "pydantic",
@@ -12,7 +11,6 @@ __requirements__ = [
     "fastapi",
     "uvicorn",
     "PyYaml",
-    # engine
     "openai",
     "tiktoken",
     "google-auth",

llmstudio-0.2.2/llmstudio/engine/__init__.py

@@ -0,0 +1,199 @@
+from typing import Any, Callable, Dict, Optional
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+
+from llmstudio.engine.config import EngineRouteConfig, Route, RouteType
+from llmstudio.engine.constants import ENGINE_HEALTH_ENDPOINT, ENGINE_ROUTE_BASE, VERSION
+from llmstudio.engine.providers import get_provider
+
+
+class EngineAPI(FastAPI):
+    """
+    Extends FastAPI to provide an API engine with dynamic routes based on the given configuration.
+
+    Attributes:
+        dynamic_routes (Dict[str, Route]): A dictionary mapping from route names to Route objects.
+    """
+
+    def __init__(self, config: EngineRouteConfig, *args: Any, **kwargs: Any):
+        """
+        Initialize the EngineAPI instance.
+
+        Args:
+            config (EngineRouteConfig): The configuration object containing routes and other settings.
+            *args (Any): Additional positional arguments.
+            **kwargs (Any): Additional keyword arguments.
+        """
+        super().__init__(*args, **kwargs)
+        self.dynamic_routes: Dict[str, Route] = {}
+        self.set_dynamic_routes(config)
+
+    def set_dynamic_routes(self, config: EngineRouteConfig) -> None:
+        """
+        Clears existing dynamic routes and sets new ones based on the provided configuration.
+
+        Args:
+            config (EngineRouteConfig): The configuration object containing routes and other settings.
+        """
+        self.dynamic_routes.clear()
+        for route in config.routes:
+            for provider in route.model_providers:
+                self._add_dynamic_route(route, provider)
+
+    def _add_dynamic_route(self, route: dict, provider: dict):
+        """
+        Internal method to add a dynamic route based on route and provider information.
+
+        Args:
+            route (dict): Dictionary containing information about the route.
+            provider (dict): Dictionary containing information about the provider.
+        """
+        provider_name = provider.provider
+        provider_config = provider.config or {}
+        route_type_name = f"{route.route_type.value}/{provider_name}"
+        path = f"{ENGINE_ROUTE_BASE}{route_type_name}"
+
+        self.add_api_route(
+            path=path,
+            endpoint=self._route_type_to_endpoint(
+                provider_name, provider_config, route.route_type
+            ),
+            methods=["POST"],
+        )
+        self.dynamic_routes[route_type_name] = route.to_route(provider_name, path)
+
+    def _route_type_to_endpoint(
+        self, provider_name: str, provider_config: dict, route_type: RouteType
+    ) -> Callable:
+        """
+        Maps a route type to its corresponding endpoint callable based on provider information.
+
+        Args:
+            provider_name (str): The name of the provider.
+            provider_config (dict): Configuration specific to the provider.
+            route_type (RouteType): The type of the route.
+
+        Returns:
+            Callable: The callable endpoint to be used for the route.
+
+        Raises:
+            HTTPException: If the route type is unexpected for the given provider.
+        """
+        provider_to_factory = {
+            RouteType.LLM_CHAT: "chat",
+            RouteType.LLM_VALIDATION: "test",
+        }
+
+        factory = provider_to_factory.get(route_type)
+        if factory:
+            return self._create_generic_endpoint(factory, provider_name, provider_config)
+
+        raise HTTPException(
+            status_code=404,
+            detail=f"Unexpected route type {route_type!r} for provider {provider_name!r}.",
+        )
+
+    def _create_generic_endpoint(
+        self, method_name: str, provider_name: str, provider_config: str
+    ) -> Callable:
+        """
+        Creates a generic endpoint for the given method name and provider.
+
+        Args:
+            method_name (str): The method name that should be invoked on the provider.
+            provider_name (str): The name of the provider.
+            provider_config (str): Configuration specific to the provider.
+
+        Returns:
+            Callable: A generic endpoint that invokes the specified method on the provider.
+
+        Raises:
+            HTTPException: If the specified method is not found for the given provider.
+        """
+
+        async def _generic_endpoint(request: Request):
+            payload = await request.json()
+            api_key = payload.get("api_key", None)
+            provider_instance = get_provider(provider_name)(provider_config, api_key)
+            method = getattr(provider_instance, method_name, None)
+
+            if not method:
+                raise HTTPException(
+                    status_code=404,
+                    detail=f"Method {method_name!r} not found for provider {provider_name!r}.",
+                )
+
+            return await method(payload)
+
+        return _generic_endpoint
+
+    def get_dynamic_route(self, route_name: str) -> Optional[Route]:
+        """
+        Retrieves the dynamic route by its name.
+
+        Args:
+            route_name (str): The name of the route to retrieve.
+
+        Returns:
+            Optional[Route]: The Route object if found, None otherwise.
+        """
+        return self.dynamic_routes.get(route_name)
+
+    def get_dynamic_routes(self):
+        """
+        Retrieves all dynamic routes.
+
+        Returns:
+            Dict[str, Route]: A dictionary of all dynamic routes, keyed by route name.
+        """
+        return self.dynamic_routes
+
+
+def create_app_from_config(config: EngineRouteConfig) -> EngineAPI:
+    """
+    Initializes and returns an EngineAPI application based on the given configuration.
+
+    Parameters:
+    config (EngineRouteConfig): The configuration settings for initializing the EngineAPI.
+
+    Returns:
+    EngineAPI: An initialized EngineAPI application.
+    """
+    app = EngineAPI(
+        config=config,
+        title="engine API",
+        description="The core API for engine",
+        version=VERSION,
+    )
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["http://localhost:3000"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    @app.get(ENGINE_HEALTH_ENDPOINT)
+    async def health():
+        return {"status": "OK"}
+
+    @app.get(ENGINE_ROUTE_BASE + "{route_name}")
+    async def get_route(route_name: str) -> Route:
+        if matched := app.get_dynamic_route(route_name):
+            return matched
+
+        raise HTTPException(
+            status_code=404,
+            detail=f"The route '{route_name}' is not present or active on the server. Please "
+            "verify the route name.",
+        )
+
+    @app.get(ENGINE_ROUTE_BASE)
+    async def search_routes(page_token: Optional[str] = None):
+        # TODO: Implement better function
+        routes = app.get_dynamic_routes()
+        return routes
+
+    return app

llmstudio-0.2.2/llmstudio/engine/config.py

@@ -0,0 +1,405 @@
+import json
+import os
+import pathlib
+from enum import Enum
+from pathlib import Path
+from typing import List, Optional, Union
+
+import pydantic
+import yaml
+from packaging import version
+from pydantic import BaseModel, ValidationError, validator
+from pydantic.json import pydantic_encoder
+
+from llmstudio.engine.utils import (
+    check_configuration_route_name_collisions,
+    is_valid_endpoint_name,
+)
+
+IS_PYDANTIC_V2 = version.parse(pydantic.version.VERSION) >= version.parse("2.0")
+
+
+class EngineConfig:
+    def __init__(
+        self,
+        api_name="Engine",
+        host="localhost",
+        port=8000,
+        localhost=True,
+        config_path=os.path.join(os.path.dirname(__file__), "config.yaml"),
+        health_endpoint="health",
+        routes_endpoint="api/engine",
+    ):
+        self.api_name = api_name
+        self.host = host
+        self.port = port
+        self.config_path = config_path
+        self.localhost = localhost
+        self.update_url()
+        self.update_endpoints(health_endpoint, routes_endpoint)
+
+    def update_url(self):
+        """Update the URL based on the current host, port and localhost values."""
+        self.url = f"http://{self.host}:{self.port}" if self.localhost else self.host
+
+    def update_endpoints(self, health_endpoint, routes_endpoint):
+        """Update the health and routes endpoints based on the current url."""
+        self.health_endpoint = f"{self.url}/{health_endpoint}"
+        self.routes_endpoint = f"{self.url}/{routes_endpoint}"
+
+
+class RouteType(str, Enum):
+    """
+    Used for specifying various types of routes in an API.
+    """
+
+    LLM_CHAT = "chat"
+    LLM_VALIDATION = "validation"
+
+
+class Provider(str, Enum):
+    """
+    Enum class to represent different AI service providers.
+    """
+
+    OPENAI = "openai"
+    VERTEXAI = "vertexai"
+    BEDROCK = "bedrock"
+
+    @classmethod
+    def values(cls):
+        return {p.value for p in cls}
+
+
+class OpenAIConfig(BaseModel):
+    """
+    OpenAIConfig is a class derived from BaseModel for handling the configuration needed for OpenAI API calls.
+
+    Attributes:
+    api_key (str): The API key for authentication.
+    openai_api_type (str, optional): Type of the OpenAI API to use, default is 'openai'.
+    openai_api_base (str, optional): Base URL for the OpenAI API, default is None.
+    openai_api_version (str, optional): API version, default is None.
+    openai_deployment_name (str, optional): Name of the deployment, default is None.
+    openai_organization (str, optional): Name of the organization, default is None.
+    """
+
+    api_key: str
+    openai_api_type: Optional[str] = "openai"
+    openai_api_base: Optional[str] = None
+    openai_api_version: Optional[str] = None
+    openai_deployment_name: Optional[str] = None
+    openai_organization: Optional[str] = None
+
+    @validator("api_key", pre=True)
+    def validate_api_key(cls, value):
+        return _resolve_api_key_from_input(value)
+
+
+class VertexAIConfig(BaseModel):
+    """
+    VertexAIConfig is a class derived from BaseModel for handling the configuration needed for VertexAI API calls.
+
+    Attributes:
+    api_key (dict): The JSON API key for authentication.
+    """
+
+    api_key: dict
+
+    @validator("api_key", pre=True)
+    def validate_api_key(cls, value):
+        return _resolve_api_key_from_input(value)
+
+
+class BedrockConfig(BaseModel):
+    """
+    BedrockConfig is a class derived from BaseModel for handling the configuration needed for Bedrock API calls.
+
+    Attributes:
+    api_key (dict): The JSON API key for authentication.
+    """
+
+    api_key: dict
+
+    @validator("api_key", pre=True)
+    def validate_api_key(cls, value):
+        return _resolve_api_key_from_input(value)
+
+
+provider_configs = {
+    Provider.OPENAI: OpenAIConfig,
+    Provider.VERTEXAI: VertexAIConfig,
+    Provider.BEDROCK: BedrockConfig,
+}
+
+
+def _resolve_api_key_from_input(api_key_input):
+    """
+    Resolves the provided API key.
+
+    Input formats accepted:
+
+    - Path to a file as a string which will have the key loaded from it
+    - environment variable name that stores the api key
+    - the api key itself
+    """
+
+    if isinstance(api_key_input, dict):
+        api_key_input = api_key_input.get("api_key")
+
+    # try reading as an environment variable
+    if api_key_input.startswith("$"):
+        env_var_name = api_key_input[1:]
+        if env_var := os.getenv(env_var_name):
+            return env_var
+        else:
+            raise ValueError(f"Environment variable {env_var_name!r} is not set")
+
+    # try reading from a local path
+    file = pathlib.Path(api_key_input)
+    if file.is_file():
+        return file.read_text()
+
+    # if the key itself is passed, return
+    return api_key_input
+
+
+class ModelProvider(BaseModel):
+    """
+    Represents a provider for machine learning models along with its configuration.
+
+    Attributes:
+        provider (Union[str, Provider]): The provider of the machine learning model.
+        config (Optional[Union[OpenAIConfig, ...]]): The configuration for the selected provider.
+    """
+
+    provider: Union[str, Provider]
+    config: Optional[
+        Union[
+            OpenAIConfig,
+            VertexAIConfig,
+            BedrockConfig,
+        ]
+    ] = None
+
+    @validator("provider", pre=True)
+    def validate_provider(cls, value):
+        """
+        Validates the 'provider' field.
+
+        Parameters:
+            value: The value to validate, can be either a string or an instance of the Provider enum.
+
+        Returns:
+            Provider: A valid Provider enum instance.
+
+        Raises:
+            ValueError: If the provided value is not a valid provider.
+        """
+        if isinstance(value, Provider):
+            return value
+        formatted_value = value.replace("-", "_").upper()
+        if formatted_value in Provider.__members__:
+            return Provider[formatted_value]
+        raise ValueError(f"The provider '{value}' is not supported.")
+
+    @classmethod
+    def _validate_config(cls, info, values):
+        """
+        Internal method to validate the 'config' field based on the provided 'provider'.
+
+        Parameters:
+            info: The configuration information to validate.
+            values: Dictionary containing other field values of the class, primarily used to fetch 'provider'.
+
+        Returns:
+            The validated configuration as an instance of the appropriate configuration class.
+
+        Raises:
+            ValueError: If a valid 'provider' is not provided.
+        """
+        if provider := values.get("provider"):
+            config_type = provider_configs[provider]
+            return config_type(**info)
+
+        raise ValueError("A provider must be provided for each gateway route.")
+
+    if IS_PYDANTIC_V2:
+
+        @validator("config", pre=True)
+        def validate_config(cls, info, values):
+            return cls._validate_config(info, values)
+
+    else:
+
+        @validator("config", pre=True)
+        def validate_config(cls, config, values):
+            return cls._validate_config(config, values)
+
+
+class RouteConfig(BaseModel):
+    """
+    Represents the configuration for a single route.
+
+    Attributes:
+        name (str): The name of the route.
+        route_type (RouteType): The type of the route, as defined in the RouteType enum.
+        model_providers (List[ModelProvider]): A list of model providers for the route.
+    """
+
+    name: str
+    route_type: RouteType
+    model_providers: List[ModelProvider]
+
+    @validator("name", pre=True)
+    def validate_endpoint_name(cls, route_name):
+        """
+        Validates that the provided route name is a valid endpoint name.
+
+        Args:
+            route_name (str): The name of the route.
+
+        Returns:
+            str: The validated name.
+
+        Raises:
+            ValueError: If the name contains invalid characters.
+        """
+        if not is_valid_endpoint_name(route_name):
+            raise ValueError(
+                "The route name provided contains disallowed characters for a url endpoint. "
+                f"'{route_name}' is invalid. Names cannot contain spaces or any non "
+                "alphanumeric characters other than hyphen and underscore."
+            )
+        return route_name
+
+    @validator("model_providers", pre=True)
+    def validate_model(cls, model_providers):
+        """
+        Validates that the provided model providers list is not empty and contains valid entries.
+
+        Args:
+            model_providers (List[Dict]): A list of dictionaries containing model provider information.
+
+        Returns:
+            List[Dict]: The validated list of model providers.
+
+        Raises:
+            ValueError: If the list is empty or contains invalid providers.
+        """
+        if not model_providers:
+            raise ValueError(
+                "No model providers were provided for the route. Please provide at least one model provider."
+            )
+        for model_provider in model_providers:
+            if model_provider:
+                model_instance = ModelProvider(**model_provider)
+                if model_instance.provider not in Provider.values():
+                    raise ValueError(
+                        f"The provider entry for {model_instance.provider} is incorrect. Providers accepted are {Provider.values()}"
+                    )
+        return model_providers
+
+    @validator("route_type", pre=True)
+    def validate_route_type(cls, value):
+        """
+        Validates that the provided route type is a valid RouteType enum value.
+
+        Args:
+            value (str): The type of the route.
+
+        Returns:
+            str: The validated route type.
+
+        Raises:
+            ValueError: If the route_type is not a valid RouteType enum value.
+        """
+        if value in RouteType._value2member_map_:
+            return value
+        raise ValueError(
+            f"The route_type '{value}' is not supported. Please use one of {RouteType._value2member_map_}"
+        )
+
+    def to_route(self, name, route_url) -> "Route":
+        """
+        Converts the configuration to a Route object.
+
+        Args:
+            name (str): The name of the route.
+            route_url (str): The URL for the route.
+
+        Returns:
+            Route: A Route object containing the route's configuration.
+        """
+        return Route(
+            name=name,
+            route_type=self.route_type,
+            route_url=route_url,
+        )
+
+
+class Route(BaseModel):
+    """
+    A class to represent a routing information.
+
+    Attributes:
+        name (str): The name of the route.
+        route_type (str): The type of the route, usually represented as a string-based identifier.
+        route_url (str): The URL pattern for the route.
+
+    Config:
+        schema_extra: Provides an example instantiation of the Route class.
+    """
+
+    name: str
+    route_type: str
+    route_url: str
+
+    class Config:
+        schema_extra = {
+            "example": {
+                "name": "openai",
+                "route_type": "llm/v1/completions",
+                "route_url": "/engine/openai",
+            }
+        }
+
+
+class EngineRouteConfig(BaseModel):
+    routes: List[RouteConfig]
+
+
+def _load_route_config(path: Union[str, Path]) -> EngineRouteConfig:
+    """
+    Reads the gateway configuration yaml file from the storage location and returns an instance
+    of the configuration RouteConfig class
+    """
+    if isinstance(path, str):
+        path = Path(path)
+    try:
+        configuration = yaml.safe_load(path.read_text())
+    except Exception as e:
+        raise ValueError(f"The file at {path} is not a valid yaml file") from e
+    check_configuration_route_name_collisions(configuration)
+    try:
+        return EngineRouteConfig(**configuration)
+    except ValidationError as e:
+        raise ValueError(f"The gateway configuration is invalid: {e}") from e
+
+
+def _save_route_config(config: EngineRouteConfig, path: Union[str, Path]) -> None:
+    if isinstance(path, str):
+        path = Path(path)
+    path.write_text(
+        yaml.safe_dump(json.loads(json.dumps(config.dict(), default=pydantic_encoder)))
+    )
+
+
+def _validate_config(config_path: str) -> EngineRouteConfig:
+    if not os.path.exists(config_path):
+        raise ValueError(f"{config_path} does not exist")
+
+    try:
+        return _load_route_config(config_path)
+    except ValidationError as e:
+        raise ValueError(f"Invalid gateway configuration: {e}") from e

llmstudio-0.2.2/llmstudio/engine/constants.py

@@ -0,0 +1,28 @@
+ENGINE_ROUTE_BASE = "/api/engine/"
+ENGINE_HEALTH_ENDPOINT = "/health"
+
+
+# Change to llmstudio version
+VERSION = "0.1.0"
+
+
+END_TOKEN = "<END_TOKEN>"
+
+VERTEXAI_TOKEN_PRICE = 0.0000005
+
+
+OPENAI_PRICING_DICT = {
+    "gpt-3.5-turbo": {"input_tokens": 0.0000015, "output_tokens": 0.000002},
+    "gpt-4": {"input_tokens": 0.00003, "output_tokens": 0.00006},
+    "gpt-3.5-turbo-16k": {"input_tokens": 0.00003, "output_tokens": 0.00004},
+}
+
+
+TITAN_MODELS = ["amazon.titan-tg1-large"]
+CLAUDE_MODELS = [
+    "anthropic.claude-instant-v1",
+    "anthropic.claude-v1",
+    "anthropic.claude-v2",
+]
+
+BEDROCK_MODELS = TITAN_MODELS + CLAUDE_MODELS

llmstudio-0.2.2/llmstudio/engine/utils.py

@@ -0,0 +1,59 @@
+import re
+
+
+def is_valid_endpoint_name(name: str) -> bool:
+    """
+    Check whether a string contains any URL reserved characters, spaces, or characters other
+    than alphanumeric, underscore, hyphen, and dot.
+
+    Returns True if the string doesn't contain any of these characters.
+    """
+    pattern = r"[^\w\.-]"
+    return re.search(pattern, name) is None
+
+
+def validate_provider_config(config, api_key):
+    """
+    Validate and/or initialize a provider configuration based on input parameters.
+
+    Parameters:
+    - config (dict or None): Configuration dictionary for the provider. Can be None.
+    - api_key (str or None): API key for the provider. Can be None.
+
+    Returns:
+    dict: The modified or validated configuration dictionary.
+
+    Raises:
+    - ValueError: If both `config` and `api_key` are None.
+    """
+    if not (config or api_key):
+        raise ValueError(f"Config was not specified neither an api_key was provided.")
+    if config is None:
+        config = {}
+    if api_key is not None:
+        config.setdefault("api_key", api_key)
+    return config
+
+
+def check_configuration_route_name_collisions(config):
+    """
+    Checks for duplicate route names in the given configuration.
+
+    Parameters:
+        config (dict): The configuration dictionary containing a list of routes.
+                    Each route should be a dictionary with a 'name' key.
+
+    Returns:
+        None: Returns None if there are no duplicates.
+
+    Raises:
+        ValueError: If there are duplicate route names found in the configuration.
+    """
+    if len(config["routes"]) < 2:
+        return
+    names = [route["name"] for route in config["routes"]]
+    if len(names) != len(set(names)):
+        raise ValueError(
+            "Duplicate names found in route configurations. Please remove the duplicate route "
+            "name from the configuration to ensure that route endpoints are created properly."
+        )

llmstudio-0.2.2/llmstudio/models/__init__.py

@@ -0,0 +1,4 @@
+from .bedrock import BedrockClient
+from .models import LLMClient, LLMModel
+from .openai import OpenAIClient
+from .vertexai import VertexAIClient

{llmstudio-0.2.0 → llmstudio-0.2.2}/llmstudio/models/bedrock.py

@@ -1,7 +1,7 @@
-from llmstudoi.models import LLMClient, LLMModel
-
 from llmstudio.engine.config import EngineConfig
-from llmstudio.validators import ClaudeParameters, TitanParameters
+
+from ..validators import ClaudeParameters, TitanParameters
+from .models import LLMClient, LLMModel
 
 
 class BedrockClient(LLMClient):

{llmstudio-0.2.0 → llmstudio-0.2.2}/llmstudio/models/openai.py

@@ -1,8 +1,9 @@
 import os
 
 from llmstudio.engine.config import EngineConfig
-from llmstudio.models import LLMClient, LLMModel
-from llmstudio.validators import OpenAIParameters
+
+from ..validators import OpenAIParameters
+from .models import LLMClient, LLMModel
 
 
 class OpenAIClient(LLMClient):

{llmstudio-0.2.0 → llmstudio-0.2.2}/llmstudio/models/vertexai.py

@@ -1,6 +1,7 @@
 from llmstudio.engine.config import EngineConfig
-from llmstudio.models import LLMClient, LLMModel
-from llmstudio.validators import VertexAIParameters
+
+from ..validators import VertexAIParameters
+from .models import LLMClient, LLMModel
 
 
 class VertexAIClient(LLMClient):

llmstudio-0.2.2/llmstudio/ui/__init__.py

@@ -0,0 +1,21 @@
+import os
+
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+
+
+def create_ui_app():
+    app = FastAPI()
+
+    app.mount(
+        "/static",
+        StaticFiles(directory=os.path.join(os.path.dirname(__file__), "build", "static")),
+        name="static",
+    )
+    app.mount(
+        "/",
+        StaticFiles(directory=os.path.join(os.path.dirname(__file__), "build"), html=True),
+        name="app",
+    )
+
+    return app

llmstudio-0.2.2/llmstudio/utils/rest_utils.py

@@ -0,0 +1,53 @@
+from threading import Thread
+
+import requests
+import uvicorn
+
+from llmstudio.engine import create_app_from_config
+from llmstudio.engine.config import EngineConfig, _load_route_config
+
+
+def is_api_running(url, name) -> bool:
+    try:
+        response = requests.get(url, timeout=5)
+        if response.status_code == 200:
+            print(f"API {name} is already running")
+            return True
+    except requests.RequestException as e:
+        return False
+
+
+def run_engine_app(engine_config=EngineConfig()):
+    config = _load_route_config(engine_config.config_path)
+    engine = create_app_from_config(config)
+    print(f"Running {engine_config.api_name} on {engine_config.host}:{engine_config.port}")
+    uvicorn.run(
+        engine,
+        host=engine_config.host,
+        port=engine_config.port,
+        log_level="critical",
+    )
+
+
+def run_ui_app(ui_server_app):
+    uvicorn.run(
+        ui_server_app,
+        host="localhost",
+        port=3000,
+        log_level="critical",
+    )
+
+
+def run_apis(engine_config=EngineConfig(), ui_server_app=None, serverless=False):
+    if engine_config.localhost and not is_api_running(
+        engine_config.health_endpoint, engine_config.api_name
+    ):
+        thread = Thread(target=run_engine_app, args=(engine_config,))
+        thread.daemon = True
+        thread.start()
+
+    if ui_server_app:
+        thread = Thread(target=run_ui_app, args=(ui_server_app,))
+        thread.daemon = True
+        thread.start()
+        thread.join()

llmstudio-0.2.2/llmstudio/validators/__init__.py

@@ -0,0 +1,3 @@
+from .bedrock import ClaudeParameters, TitanParameters
+from .openai import OpenAIParameters
+from .vertexai import VertexAIParameters

llmstudio-0.2.2/llmstudio/validators/bedrock.py

@@ -0,0 +1,35 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class ClaudeParameters(BaseModel):
+    """
+    Model for validating and storing parameters specific to Claude model.
+
+    Attributes:
+        temperature (Optional[float]): Controls randomness in the model's output.
+        max_tokens (Optional[int]): The maximum number of tokens in the output.
+        top_p (Optional[float]): Influences the diversity of output by controlling token sampling.
+        top_k (Optional[float]): Sets the number of the most likely next tokens to filter for.
+    """
+
+    temperature: Optional[float] = Field(1, ge=0, le=1)
+    max_tokens: Optional[int] = Field(300, ge=1, le=2048)
+    top_p: Optional[float] = Field(0.999, ge=0, le=1)
+    top_k: Optional[int] = Field(250, ge=1, le=500)
+
+
+class TitanParameters(BaseModel):
+    """
+    Model for validating and storing parameters specific to Titan model.
+
+    Attributes:
+        temperature (Optional[float]): Controls randomness in the model's output.
+        max_tokens (Optional[int]): The maximum number of tokens in the output.
+        top_p (Optional[float]): Influences the diversity of output by controlling token sampling.
+    """
+
+    temperature: Optional[float] = Field(0, ge=0, le=1)
+    max_tokens: Optional[int] = Field(512, ge=1, le=4096)
+    top_p: Optional[float] = Field(0.9, ge=0.1, le=1)

llmstudio-0.2.2/llmstudio/validators/openai.py

@@ -0,0 +1,22 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class OpenAIParameters(BaseModel):
+    """
+    A Pydantic model for encapsulating parameters used in OpenAI API requests.
+
+    Attributes:
+        temperature (Optional[float]): Controls randomness in the model's output.
+        max_tokens (Optional[int]): The maximum number of tokens in the output.
+        top_p (Optional[float]): Influences the diversity of output by controlling token sampling.
+        frequency_penalty (Optional[float]): Modifies the likelihood of tokens appearing based on their frequency.
+        presence_penalty (Optional[float]): Adjusts the likelihood of new tokens appearing.
+    """
+
+    temperature: Optional[float] = Field(default=1, ge=0, le=2)
+    max_tokens: Optional[int] = Field(default=256, ge=1, le=2048)
+    top_p: Optional[float] = Field(default=1, ge=0, le=1)
+    frequency_penalty: Optional[float] = Field(default=0, ge=0, le=1)
+    presence_penalty: Optional[float] = Field(default=0, ge=0, le=1)

llmstudio-0.2.2/llmstudio/validators/vertexai.py

@@ -0,0 +1,20 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class VertexAIParameters(BaseModel):
+    """
+    A Pydantic model that encapsulates parameters used for VertexAI API requests.
+
+    Attributes:
+        temperature (Optional[float]): Controls randomness in the model's output.
+        max_tokens (Optional[int]): The maximum number of tokens in the output.
+        top_p (Optional[float]): Influences the diversity of output by controlling token sampling.
+        top_k (Optional[float]): Sets the number of the most likely next tokens to filter for.
+    """
+
+    temperature: Optional[float] = Field(1, ge=0, le=1)
+    max_tokens: Optional[int] = Field(256, ge=1, le=1024)
+    top_p: Optional[float] = Field(1, ge=0, le=1)
+    top_k: Optional[float] = Field(40, ge=1, le=40)

{llmstudio-0.2.0 → llmstudio-0.2.2}/llmstudio.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: llmstudio
-Version: 0.2.0
+Version: 0.2.2
 Summary: Prompt Perfection at Your Fingertips
 Home-page: https://llmstudio.ai/
 Author: TensorOps
@@ -8,5 +8,6 @@ Author-email: contact@tensorops.ai
 Project-URL: Source Code, https://github.com/tensoropsai/llmstudio
 Project-URL: Bug Tracker, https://github.com/tensoropsai/llmstudio/issues
 Project-URL: Documentation, https://docs.llmstudio.ai
-Keywords: ml ai llm llmstudio tensorops
+Keywords: ml ai llm llmops openai langchain chatgpt llmstudio tensorops
+Requires-Python: ~=3.9
 License-File: LICENSE

{llmstudio-0.2.0 → llmstudio-0.2.2}/llmstudio.egg-info/SOURCES.txt

@@ -10,8 +10,18 @@ llmstudio.egg-info/dependency_links.txt
 llmstudio.egg-info/entry_points.txt
 llmstudio.egg-info/requires.txt
 llmstudio.egg-info/top_level.txt
+llmstudio/engine/__init__.py
+llmstudio/engine/config.py
+llmstudio/engine/constants.py
+llmstudio/engine/utils.py
 llmstudio/models/__init__.py
 llmstudio/models/bedrock.py
 llmstudio/models/models.py
 llmstudio/models/openai.py
-llmstudio/models/vertexai.py
+llmstudio/models/vertexai.py
+llmstudio/ui/__init__.py
+llmstudio/utils/rest_utils.py
+llmstudio/validators/__init__.py
+llmstudio/validators/bedrock.py
+llmstudio/validators/openai.py
+llmstudio/validators/vertexai.py

{llmstudio-0.2.0 → llmstudio-0.2.2}/setup.py

@@ -14,14 +14,26 @@ setup(
     },
     author_email="contact@tensorops.ai",
     description="Prompt Perfection at Your Fingertips",
-    keywords="ml ai llm llmstudio tensorops",
+    keywords="ml ai llm llmops openai langchain chatgpt llmstudio tensorops",
     version=SDK_VERSION,
-    packages=["llmstudio", "llmstudio.models"],
+    packages=[
+        "llmstudio",
+        "llmstudio.engine",
+        "llmstudio.models",
+        "llmstudio.ui",
+        "llmstudio.utils",
+        "llmstudio.validators",
+    ],
     package_dir={
         "llmstudio": "llmstudio",
+        "llmstudio.engine": "llmstudio/engine",
         "llmstudio.models": "llmstudio/models",
+        "llmstudio.ui": "llmstudio/ui",
+        "llmstudio.utils": "llmstudio/utils",
+        "llmstudio.validators": "llmstudio/validators",
     },
     install_requires=REQUIREMENTS,
     include_package_data=True,
     entry_points={"console_scripts": ["llmstudio = llmstudio.cli:main"]},
+    python_requires="~=3.9",
 )