versionhq 1.1.4.4__py3-none-any.whl

versionhq/clients/product/model.py

@@ -0,0 +1,74 @@
+import uuid
+from typing import Any, Dict, List, Callable, Type, Optional, get_args, get_origin
+from pydantic import (
+    UUID4,
+    InstanceOf,
+    BaseModel,
+    ConfigDict,
+    Field,
+    create_model,
+    field_validator,
+    model_validator,
+)
+from pydantic_core import PydanticCustomError
+
+
+class ProductProvider(BaseModel):
+    """
+    Store the minimal client information.
+    `data_pipeline` and `destinations` are for composio plug-in.
+    (!REFINEME) Create an Enum list for the options.
+    (!REFINEME) Create an Enum list for regions.
+    """
+
+    id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
+    name: Optional[str] = Field(default=None, description="client name")
+    region: Optional[str] = Field(
+        default=None, description="region of client's main business operation"
+    )
+    data_pipeline: Optional[List[str]] = Field(
+        default=None, description="store the data pipelines that the client is using"
+    )
+    destinations: Optional[List[str]] = Field(
+        default=None,
+        description="store the destination services that the client is using",
+    )
+
+    @field_validator("id", mode="before")
+    @classmethod
+    def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
+        if v:
+            raise PydanticCustomError(
+                "may_not_set_field", "This field is not to be set by the user.", {}
+            )
+
+
+class Product(BaseModel):
+    """
+    Store the product information necessary to the outbound effrots and connect it to the `ProductProvider` instance.
+    """
+
+    id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
+    name: Optional[str] = Field(default=None, description="product name")
+    description: Optional[str] = Field(
+        default=None,
+        max_length=256,
+        description="product description scraped from landing url or client input. cascade to the agent",
+    )
+    provider: Optional[ProductProvider] = Field(default=None)
+    audience: Optional[str] = Field(default=None, description="target audience")
+    usp: Optional[str] = Field(default=None)
+    landing_url: Optional[str] = Field(
+        default=None, description="marketing url of the product if any"
+    )
+    cohort_timeframe: Optional[int] = Field(
+        default=30, description="ideal cohort timeframe of the product in days"
+    )
+
+    @field_validator("id", mode="before")
+    @classmethod
+    def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
+        if v:
+            raise PydanticCustomError(
+                "may_not_set_field", "This field is not to be set by the user.", {}
+            )

versionhq/clients/workflow/model.py

@@ -0,0 +1,174 @@
+import uuid
+from abc import ABC
+from datetime import date, datetime, time, timedelta
+from typing import (
+    Any,
+    Dict,
+    List,
+    Union,
+    Callable,
+    Type,
+    Optional,
+    get_args,
+    get_origin,
+)
+from pydantic import (
+    UUID4,
+    InstanceOf,
+    BaseModel,
+    ConfigDict,
+    Field,
+    create_model,
+    field_validator,
+    model_validator,
+)
+from pydantic_core import PydanticCustomError
+
+from versionhq.clients.product.model import Product
+from versionhq.clients.customer.model import Customer
+from versionhq.agent.model import Agent
+from versionhq.team.model import Team
+
+
+class ScoreFormat:
+    def __init__(self, rate: float, weight: int = 1):
+        self.rate = rate
+        self.weight = weight
+        self.aggregate = rate * weight
+
+
+class Score:
+    """
+    Evaluate the score on 0 (no performance) to 1 scale.
+    `rate`: Any float from 0.0 to 1.0 given by an agent.
+    `weight`: Importance of each factor to the aggregated score.
+    """
+
+    def __init__(
+        self,
+        brand_tone: ScoreFormat,
+        audience: ScoreFormat,
+        track_record: ScoreFormat,
+        *args: List[ScoreFormat],
+    ):
+        self.brand_tone = brand_tone
+        self.audience = audience
+        self.track_record = track_record
+        self.args = args
+
+    def result(self):
+        aggregated_score = sum(
+            self.brand_tone.aggregate,
+            self.audience.aggregate,
+            self.track_record.aggrigate,
+        )
+        denominator = sum(
+            self.brand_tone.weight, self.audience.weight, self.track_record.weight
+        )
+        try:
+            if self.args:
+                for item in self.args:
+                    if isinstance(item, ScoreFormat):
+                        aggregate_score += item.rate * item.weight
+                        denominator += item.weight
+        except:
+            pass
+        return round(aggregated_score / denominator, 2)
+
+
+class MessagingComponent(ABC, BaseModel):
+    layer_id: int = Field(default=0, description="add id of the layer: 0, 1, 2")
+    message: str = Field(
+        default=None, max_length=1024, description="text message content to be sent"
+    )
+    interval: Optional[str] = Field(
+        default=None,
+        description="interval to move on to the next layer. if this is the last layer, set as `None`",
+    )
+    score: Union[float, InstanceOf[Score]] = Field(default=None)
+
+
+class MessagingWorkflow(ABC, BaseModel):
+    """
+    Store 3 layers of messaging workflow sent to `customer` on the `product`
+    """
+
+    _created_at: Optional[datetime]
+    _updated_at: Optional[datetime]
+
+    model_config = ConfigDict()
+
+    id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
+    comps: List[MessagingComponent] = Field(
+        default=list, description="store at least 3 messaging components"
+    )
+
+    # responsible tean or agents
+    team: Optional[Team] = Field(
+        default=None,
+        description="store `Team` instance responsibile for autopiloting this workflow",
+    )
+    agents: Optional[List[Agent]] = Field(
+        default=None,
+        description="store `Agent` instances responsible for autopiloting this workflow. if the team exsits, this field remains as `None`",
+    )
+
+    # metrics
+    destination: Optional[str] = Field(
+        default=None, description="destination service to launch this workflow"
+    )
+    product: InstanceOf[Product] = Field(default=None)
+    customer: InstanceOf[Customer] = Field(default=None)
+
+    metrics: Union[List[Dict[str, Any]], List[str]] = Field(
+        default=None,
+        max_length=256,
+        description="store metrics that used to predict and track the performance of this workflow.",
+    )
+
+    @property
+    def name(self):
+        if self.customer.id:
+            return (
+                f"Workflow ID: {self.id} - on {self.product.id} for {self.customer.id}"
+            )
+        else:
+            return f"Workflow ID: {self.id} - on {self.product.id}"
+
+    @field_validator("id", mode="before")
+    @classmethod
+    def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
+        if v:
+            raise PydanticCustomError(
+                "may_not_set_field", "This field is not to be set by the user.", {}
+            )
+
+    @model_validator(mode="after")
+    def set_up_destination(self):
+        """
+        Set up the destination service when self.destination is None.
+        Prioritize customer's destination to the product provider's destination list.
+        """
+        if self.destination is None:
+            if self.customer is not None:
+                self.destination = self.customer.on
+
+            else:
+                destination_list = self.product.provider.destinations
+                if destination_list:
+                    self.destination = destination_list[0]
+        return self
+
+    def reassign_agent_or_team(
+        self, agents: List[Agent] = None, team: Team = None
+    ) -> None:
+        """
+        Fire unresponsible agents/team and assign new one.
+        """
+
+        if not agents and not team:
+            raise ValueError("Need to add at least 1 agent or team.")
+
+        self.agents = agents
+        self.team = team
+        self.updated_at = datetime.datetime.now()

versionhq/llm/llm_vars.py

@@ -0,0 +1,173 @@
+LLM_CONTEXT_WINDOW_SIZES = {
+    "gpt-3.5-turbo": 8192,
+    "gpt-4": 8192,
+    "gpt-4o": 128000,
+    "gpt-4o-mini": 128000,
+    "gpt-4-turbo": 128000,
+    "o1-preview": 128000,
+    "o1-mini": 128000,
+    "deepseek-chat": 128000,
+    "gemma2-9b-it": 8192,
+    "gemma-7b-it": 8192,
+    "llama3-groq-70b-8192-tool-use-preview": 8192,
+    "llama3-groq-8b-8192-tool-use-preview": 8192,
+    "llama-3.1-70b-versatile": 131072,
+    "llama-3.1-8b-instant": 131072,
+    "llama-3.2-1b-preview": 8192,
+    "llama-3.2-3b-preview": 8192,
+    "llama-3.2-11b-text-preview": 8192,
+    "llama-3.2-90b-text-preview": 8192,
+    "llama3-70b-8192": 8192,
+    "llama3-8b-8192": 8192,
+    "mixtral-8x7b-32768": 32768,
+}
+
+
+LLM_VARS = {
+    "openai": [
+        {
+            "prompt": "Enter your OPENAI API key (press Enter to skip)",
+            "key_name": "OPENAI_API_KEY",
+        }
+    ],
+    "anthropic": [
+        {
+            "prompt": "Enter your ANTHROPIC API key (press Enter to skip)",
+            "key_name": "ANTHROPIC_API_KEY",
+        }
+    ],
+    "gemini": [
+        {
+            "prompt": "Enter your GEMINI API key (press Enter to skip)",
+            "key_name": "GEMINI_API_KEY",
+        }
+    ],
+    "watson": [
+        {
+            "prompt": "Enter your WATSONX URL (press Enter to skip)",
+            "key_name": "WATSONX_URL",
+        },
+        {
+            "prompt": "Enter your WATSONX API Key (press Enter to skip)",
+            "key_name": "WATSONX_APIKEY",
+        },
+        {
+            "prompt": "Enter your WATSONX Project Id (press Enter to skip)",
+            "key_name": "WATSONX_PROJECT_ID",
+        },
+    ],
+    "ollama": [
+        {
+            "default": True,
+            "API_BASE": "http://localhost:11434",
+        }
+    ],
+    "bedrock": [
+        {
+            "prompt": "Enter your AWS Access Key ID (press Enter to skip)",
+            "key_name": "AWS_ACCESS_KEY_ID",
+        },
+        {
+            "prompt": "Enter your AWS Secret Access Key (press Enter to skip)",
+            "key_name": "AWS_SECRET_ACCESS_KEY",
+        },
+        {
+            "prompt": "Enter your AWS Region Name (press Enter to skip)",
+            "key_name": "AWS_REGION_NAME",
+        },
+    ],
+    "azure": [
+        {
+            "prompt": "Enter your Azure deployment name (must start with 'azure/')",
+            "key_name": "model",
+        },
+        {
+            "prompt": "Enter your AZURE API key (press Enter to skip)",
+            "key_name": "AZURE_API_KEY",
+        },
+        {
+            "prompt": "Enter your AZURE API base URL (press Enter to skip)",
+            "key_name": "AZURE_API_BASE",
+        },
+        {
+            "prompt": "Enter your AZURE API version (press Enter to skip)",
+            "key_name": "AZURE_API_VERSION",
+        },
+    ],
+    "cerebras": [
+        {
+            "prompt": "Enter your Cerebras model name (must start with 'cerebras/')",
+            "key_name": "model",
+        },
+        {
+            "prompt": "Enter your Cerebras API version (press Enter to skip)",
+            "key_name": "CEREBRAS_API_KEY",
+        },
+    ],
+}
+
+
+PROVIDERS = [
+    "openai",
+    "anthropic",
+    "gemini",
+    "ollama",
+    "watson",
+    "bedrock",
+    "azure",
+    "cerebras",
+    "llama",
+]
+
+MODELS = {
+    "openai": ["gpt-4", "gpt-4o", "gpt-4o-mini", "o1-mini", "o1-preview"],
+    "anthropic": [
+        "claude-3-5-sonnet-20240620",
+        "claude-3-sonnet-20240229",
+        "claude-3-opus-20240229",
+        "claude-3-haiku-20240307",
+    ],
+    "gemini": [
+        "gemini/gemini-1.5-flash",
+        "gemini/gemini-1.5-pro",
+        "gemini/gemini-gemma-2-9b-it",
+        "gemini/gemini-gemma-2-27b-it",
+    ],
+    "ollama": ["ollama/llama3.1", "ollama/mixtral"],
+    "watson": [
+        "watsonx/meta-llama/llama-3-1-70b-instruct",
+        "watsonx/meta-llama/llama-3-1-8b-instruct",
+        "watsonx/meta-llama/llama-3-2-11b-vision-instruct",
+        "watsonx/meta-llama/llama-3-2-1b-instruct",
+        "watsonx/meta-llama/llama-3-2-90b-vision-instruct",
+        "watsonx/meta-llama/llama-3-405b-instruct",
+        "watsonx/mistral/mistral-large",
+        "watsonx/ibm/granite-3-8b-instruct",
+    ],
+    "bedrock": [
+        "bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
+        "bedrock/anthropic.claude-3-sonnet-20240229-v1:0",
+        "bedrock/anthropic.claude-3-haiku-20240307-v1:0",
+        "bedrock/anthropic.claude-3-opus-20240229-v1:0",
+        "bedrock/anthropic.claude-v2:1",
+        "bedrock/anthropic.claude-v2",
+        "bedrock/anthropic.claude-instant-v1",
+        "bedrock/meta.llama3-1-405b-instruct-v1:0",
+        "bedrock/meta.llama3-1-70b-instruct-v1:0",
+        "bedrock/meta.llama3-1-8b-instruct-v1:0",
+        "bedrock/meta.llama3-70b-instruct-v1:0",
+        "bedrock/meta.llama3-8b-instruct-v1:0",
+        "bedrock/amazon.titan-text-lite-v1",
+        "bedrock/amazon.titan-text-express-v1",
+        "bedrock/cohere.command-text-v14",
+        "bedrock/ai21.j2-mid-v1",
+        "bedrock/ai21.j2-ultra-v1",
+        "bedrock/ai21.jamba-instruct-v1:0",
+        "bedrock/meta.llama2-13b-chat-v1",
+        "bedrock/meta.llama2-70b-chat-v1",
+        "bedrock/mistral.mistral-7b-instruct-v0:2",
+        "bedrock/mistral.mixtral-8x7b-instruct-v0:1",
+    ],
+}
+
+JSON_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json"

versionhq/llm/model.py

@@ -0,0 +1,245 @@
+import logging
+import os
+import sys
+import threading
+import warnings
+import litellm
+from dotenv import load_dotenv
+from litellm import get_supported_openai_params
+from contextlib import contextmanager
+from typing import Any, Dict, List, Optional, Union
+
+from versionhq.llm.llm_vars import LLM_CONTEXT_WINDOW_SIZES
+from versionhq.task import TaskOutputFormat
+from versionhq.task.model import ResponseField
+
+load_dotenv(override=True)
+API_KEY_LITELLM = os.environ.get("API_KEY_LITELLM")
+DEFAULT_CONTEXT_WINDOW = int(8192 * 0.75)
+os.environ["LITELLM_LOG"] = "DEBUG"
+
+
+class FilteredStream:
+    def __init__(self, original_stream):
+        self._original_stream = original_stream
+        self._lock = threading.Lock()
+
+    def write(self, s) -> int:
+        with self._lock:
+            if (
+                "Give Feedback / Get Help: https://github.com/BerriAI/litellm/issues/new"
+                in s
+                or "LiteLLM.Info: If you need to debug this error, use `os.environ['LITELLM_LOG'] = 'DEBUG'`"
+                in s
+            ):
+                return 0
+            return self._original_stream.write(s)
+
+    def flush(self):
+        with self._lock:
+            return self._original_stream.flush()
+
+
+@contextmanager
+def suppress_warnings():
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore")
+        old_stdout = sys.stdout
+        old_stderr = sys.stderr
+        sys.stdout = FilteredStream(old_stdout)
+        sys.stderr = FilteredStream(old_stderr)
+
+        try:
+            yield
+        finally:
+            sys.stdout = old_stdout
+            sys.stderr = old_stderr
+
+
+class LLMResponseSchema:
+    """
+    Use the response schema for LLM response.
+    `field_list` contains the title, value type, bool if required of each field that needs to be returned.
+    field_list: [{ title, type, required } ]
+
+    i.e., reponse_schema
+    response_type: "array"  *options: "array", "dict"
+    propeties: { "recipe_name": { "type": "string" }, },
+    required:  ["recipe_name"]
+    """
+
+    def __init__(self, response_type: str, field_list: List[ResponseField]):
+        self.type = response_type
+        self.field_list = field_list
+
+    @property
+    def schema(self):
+        if len(self.field_list) == 0:
+            return
+
+        properties = [
+            {
+                field.title: {
+                    "type": field.type,
+                }
+            }
+            for field in self.field_list
+        ]
+        required = [field.title for field in self.field_list if field.required == True]
+        response_schema = {
+            "type": self.type,
+            "items": {"type": "object", "properties": {*properties}},
+            "required": required,
+        }
+        return response_schema
+
+
+class LLM:
+    """
+    Use LiteLLM to connect with the model of choice.
+    (Memo) Response formats will be given at the Task handling.
+    """
+
+    def __init__(
+        self,
+        model: str,
+        timeout: Optional[Union[float, int]] = None,
+        max_tokens: Optional[int] = None,
+        max_completion_tokens: Optional[int] = None,
+        context_window_size: Optional[int] = DEFAULT_CONTEXT_WINDOW,
+        callbacks: List[Any] = [],
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+        n: Optional[int] = None,
+        stop: Optional[Union[str, List[str]]] = None,
+        presence_penalty: Optional[float] = None,
+        frequency_penalty: Optional[float] = None,
+        logit_bias: Optional[Dict[int, float]] = None,
+        # response_format: Optional[Dict[str, Any]] = None,
+        seed: Optional[int] = None,
+        logprobs: Optional[bool] = None,
+        top_logprobs: Optional[int] = None,
+        base_url: Optional[str] = None,
+        api_version: Optional[str] = None,
+        api_key: Optional[str] = None,
+        **kwargs,
+    ):
+        self.model = model
+        self.timeout = timeout
+        self.max_tokens = max_tokens
+        self.max_completion_tokens = max_completion_tokens
+        self.context_window_size = context_window_size
+        self.callbacks = callbacks
+
+        self.temperature = temperature
+        self.top_p = top_p
+        self.n = n
+        self.stop = stop
+        self.presence_penalty = presence_penalty
+        self.frequency_penalty = frequency_penalty
+        self.logit_bias = logit_bias
+        # self.response_format = response_format
+        self.seed = seed
+        self.logprobs = logprobs
+        self.top_logprobs = top_logprobs
+
+        self.base_url = base_url
+        self.api_version = api_version
+        self.api_key = api_key if api_key else API_KEY_LITELLM
+
+        self.kwargs = kwargs
+
+        litellm.drop_params = True
+        self.set_callbacks(callbacks)
+
+    def call(
+        self,
+        output_formats: List[TaskOutputFormat],
+        field_list: Optional[List[ResponseField]],
+        messages: List[Dict[str, str]],
+        callbacks: List[Any] = [],
+    ) -> str:
+        """
+        Execute LLM based on Agent's controls.
+        """
+
+        with suppress_warnings():
+            if callbacks and len(callbacks) > 0:
+                self.set_callbacks(callbacks)
+
+            try:
+                response_format = None
+
+                #! REFINEME
+                if TaskOutputFormat.JSON in output_formats:
+                    response_format = LLMResponseSchema(
+                        response_type="json_object", field_list=field_list
+                    )
+
+                params = {
+                    "model": self.model,
+                    "messages": messages,
+                    "timeout": self.timeout,
+                    "temperature": self.temperature,
+                    "top_p": self.top_p,
+                    "n": self.n,
+                    "stop": self.stop,
+                    "max_tokens": self.max_tokens or self.max_completion_tokens,
+                    "presence_penalty": self.presence_penalty,
+                    "frequency_penalty": self.frequency_penalty,
+                    "logit_bias": self.logit_bias,
+                    # "response_format": response_format,
+                    "seed": self.seed,
+                    "logprobs": self.logprobs,
+                    "top_logprobs": self.top_logprobs,
+                    "api_base": self.base_url,
+                    "api_version": self.api_version,
+                    "api_key": self.api_key,
+                    "stream": False,
+                    **self.kwargs,
+                }
+                params = {k: v for k, v in params.items() if v is not None}
+                res = litellm.completion(**params)
+                return res["choices"][0]["message"]["content"]
+
+            except Exception as e:
+                logging.error(f"LiteLLM call failed: {str(e)}")
+                return None
+
+    def supports_function_calling(self) -> bool:
+        try:
+            params = get_supported_openai_params(model=self.model)
+            return "response_format" in params
+        except Exception as e:
+            logging.error(f"Failed to get supported params: {str(e)}")
+            return False
+
+    def supports_stop_words(self) -> bool:
+        try:
+            params = get_supported_openai_params(model=self.model)
+            return "stop" in params
+        except Exception as e:
+            logging.error(f"Failed to get supported params: {str(e)}")
+            return False
+
+    def get_context_window_size(self) -> int:
+        """
+        Only use 75% of the context window size to avoid cutting the message in the middle.
+        """
+        return (
+            int(LLM_CONTEXT_WINDOW_SIZES.get(self.model) * 0.75)
+            if hasattr(LLM_CONTEXT_WINDOW_SIZES, self.model)
+            else DEFAULT_CONTEXT_WINDOW
+        )
+
+    def set_callbacks(self, callbacks: List[Any]):
+        callback_types = [type(callback) for callback in callbacks]
+        for callback in litellm.success_callback[:]:
+            if type(callback) in callback_types:
+                litellm.success_callback.remove(callback)
+
+        for callback in litellm._async_success_callback[:]:
+            if type(callback) in callback_types:
+                litellm._async_success_callback.remove(callback)
+
+        litellm.callbacks = callbacks

versionhq/task/__init__.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class TaskOutputFormat(str, Enum):
+    """Enum that represents the output format of a task."""
+
+    JSON = "json"
+    PYDANTIC = "pydantic"
+    RAW = "raw"