versionhq 1.1.4.4__py3-none-any.whl

versionhq/__init__.py

@@ -0,0 +1,33 @@
+import warnings
+
+warnings.filterwarnings(
+    "ignore",
+    message="Pydantic serializer warnings:",
+    category=UserWarning,
+    module="pydantic.main",
+)
+
+from versionhq.agent.model import Agent
+from versionhq.clients.customer.model import Customer
+from versionhq.clients.product.model import Product, ProductProvider
+from versionhq.clients.workflow.model import MessagingWorkflow
+from versionhq.llm.model import LLM
+from versionhq.task.model import Task, TaskOutput
+from versionhq.team.model import Team, TeamOutput
+from versionhq.tool.model import Tool
+
+
+__version__ = "1.1.4"
+__all__ = [
+    "Agent",
+    "Customer",
+    "Product",
+    "ProductProvider",
+    "MessagingWorkflow",
+    "LLM",
+    "Task",
+    "TaskOutput",
+    "Team",
+    "TeamOutput",
+    "Tool",
+]

versionhq/_utils/cache_handler.py

@@ -0,0 +1,13 @@
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, PrivateAttr
+
+
+class CacheHandler(BaseModel):
+    _cache: Dict[str, Any] = PrivateAttr(default_factory=dict)
+
+    def add(self, tool, input, output):
+        self._cache[f"{tool}-{input}"] = output
+
+    def read(self, tool, input) -> Optional[str]:
+        return self._cache.get(f"{tool}-{input}")

versionhq/_utils/i18n.py

@@ -0,0 +1,48 @@
+import json
+import os
+from typing import Dict, Optional
+
+from pydantic import BaseModel, Field, PrivateAttr, model_validator
+
+
+class I18N(BaseModel):
+    _prompts: Dict[str, Dict[str, str]] = PrivateAttr()
+    prompt_file: Optional[str] = Field(
+        default=None, description="Path to the prompt_file file to load"
+    )
+
+    @model_validator(mode="after")
+    def load_prompts(self) -> "I18N":
+        """Load prompts from a JSON file."""
+        try:
+            if self.prompt_file:
+                with open(self.prompt_file, "r", encoding="utf-8") as f:
+                    self._prompts = json.load(f)
+            else:
+                dir_path = os.path.dirname(os.path.realpath(__file__))
+                prompts_path = os.path.join(dir_path, "../translations/en.json")
+
+                with open(prompts_path, "r", encoding="utf-8") as f:
+                    self._prompts = json.load(f)
+        except:
+            return
+
+        if not self._prompts:
+            self._prompts = {}
+
+        return self
+
+    def slice(self, slice: str) -> str:
+        return self.retrieve("slices", slice)
+
+    def errors(self, error: str) -> str:
+        return self.retrieve("errors", error)
+
+    def tools(self, error: str) -> str:
+        return self.retrieve("tools", error)
+
+    def retrieve(self, kind, key) -> str:
+        try:
+            return self._prompts[kind][key]
+        except Exception as _:
+            raise Exception(f"Prompt for '{kind}':'{key}'  not found.")

versionhq/_utils/logger.py

@@ -0,0 +1,57 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel, Field, PrivateAttr
+
+
+class Printer:
+    def print(self, content: str, color: Optional[str] = None):
+        if color == "purple":
+            self._print_purple(content)
+        elif color == "red":
+            self._print_red(content)
+        elif color == "bold_green":
+            self._print_bold_green(content)
+        elif color == "bold_purple":
+            self._print_bold_purple(content)
+        elif color == "bold_blue":
+            self._print_bold_blue(content)
+        elif color == "yellow":
+            self._print_yellow(content)
+        elif color == "bold_yellow":
+            self._print_bold_yellow(content)
+        else:
+            print(content)
+
+    def _print_bold_purple(self, content):
+        print("\033[1m\033[95m {}\033[00m".format(content))
+
+    def _print_bold_green(self, content):
+        print("\033[1m\033[92m {}\033[00m".format(content))
+
+    def _print_purple(self, content):
+        print("\033[95m {}\033[00m".format(content))
+
+    def _print_red(self, content):
+        print("\033[91m {}\033[00m".format(content))
+
+    def _print_bold_blue(self, content):
+        print("\033[1m\033[94m {}\033[00m".format(content))
+
+    def _print_yellow(self, content):
+        print("\033[93m {}\033[00m".format(content))
+
+    def _print_bold_yellow(self, content):
+        print("\033[1m\033[93m {}\033[00m".format(content))
+
+
+class Logger(BaseModel):
+    verbose: bool = Field(default=False)
+    _printer: Printer = PrivateAttr(default_factory=Printer)
+
+    def log(self, level, message, color="bold_yellow"):
+        if self.verbose:
+            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            self._printer.print(
+                f"\n[{timestamp}][{level.upper()}]: {message}", color=color
+            )

versionhq/_utils/process_config.py

@@ -0,0 +1,28 @@
+from typing import Any, Dict, Type
+from pydantic import BaseModel
+
+
+def process_config(
+    values_to_update: Dict[str, Any], model_class: Type[BaseModel]
+) -> Dict[str, Any]:
+    """
+    Process the config dictionary and update the values accordingly.
+    Refer to the Pydantic model class for field validation.
+    """
+
+    if hasattr(values_to_update, "config"):
+        config = values_to_update.pop("config", {})
+    else:
+        return values_to_update
+
+    # copy values from config to the model's attributes if the attribute isn't already set.
+    for key, value in config.items():
+        if key not in model_class.model_fields or values_to_update.get(key) is not None:
+            continue
+
+        if isinstance(value, dict) and isinstance(values_to_update.get(key), dict):
+            values_to_update[key].update(value)
+        else:
+            values_to_update[key] = value
+
+    return values_to_update

versionhq/_utils/rpm_controller.py

@@ -0,0 +1,73 @@
+import threading
+import time
+from typing import Optional
+
+from pydantic import BaseModel, Field, PrivateAttr, model_validator
+
+from versionhq._utils.logger import Logger
+
+
+class RPMController(BaseModel):
+    max_rpm: Optional[int] = Field(default=None)
+    logger: Logger = Field(default_factory=lambda: Logger(verbose=False))
+    _current_rpm: int = PrivateAttr(default=0)
+    _timer: Optional[threading.Timer] = PrivateAttr(default=None)
+    _lock: Optional[threading.Lock] = PrivateAttr(default=None)
+    _shutdown_flag: bool = PrivateAttr(default=False)
+
+    @model_validator(mode="after")
+    def reset_counter(self):
+        if self.max_rpm is not None:
+            if not self._shutdown_flag:
+                self._lock = threading.Lock()
+                self._reset_request_count()
+        return self
+
+    def check_or_wait(self):
+        if self.max_rpm is None:
+            return True
+
+        def _check_and_increment():
+            if self.max_rpm is not None and self._current_rpm < self.max_rpm:
+                self._current_rpm += 1
+                return True
+            elif self.max_rpm is not None:
+                self.logger.log(
+                    "info", "Max RPM reached, waiting for next minute to start."
+                )
+                self._wait_for_next_minute()
+                self._current_rpm = 1
+                return True
+            return True
+
+        if self._lock:
+            with self._lock:
+                return _check_and_increment()
+        else:
+            return _check_and_increment()
+
+    def stop_rpm_counter(self):
+        if self._timer:
+            self._timer.cancel()
+            self._timer = None
+
+    def _wait_for_next_minute(self):
+        time.sleep(60)
+        self._current_rpm = 0
+
+    def _reset_request_count(self):
+        def _reset():
+            self._current_rpm = 0
+            if not self._shutdown_flag:
+                self._timer = threading.Timer(60.0, self._reset_request_count)
+                self._timer.start()
+
+        if self._lock:
+            with self._lock:
+                _reset()
+        else:
+            _reset()
+
+        if self._timer:
+            self._shutdown_flag = True
+            self._timer.cancel()

versionhq/_utils/usage_metrics.py

@@ -0,0 +1,31 @@
+from pydantic import BaseModel, Field
+
+
+class UsageMetrics(BaseModel):
+    """
+    Model to track usage metrics for the agent/team's execution.
+    """
+
+    total_tokens: int = Field(default=0, description="Total number of tokens used")
+    prompt_tokens: int = Field(
+        default=0, description="Number of tokens used in prompts"
+    )
+    cached_prompt_tokens: int = Field(
+        default=0, description="Number of cached prompt tokens used"
+    )
+    completion_tokens: int = Field(
+        default=0, description="Number of tokens used in completions"
+    )
+    successful_requests: int = Field(
+        default=0, description="Number of successful requests made"
+    )
+
+    def add_usage_metrics(self, usage_metrics: "UsageMetrics"):
+        """
+        Add the usage metrics from another UsageMetrics object.
+        """
+        self.total_tokens += usage_metrics.total_tokens
+        self.prompt_tokens += usage_metrics.prompt_tokens
+        self.cached_prompt_tokens += usage_metrics.cached_prompt_tokens
+        self.completion_tokens += usage_metrics.completion_tokens
+        self.successful_requests += usage_metrics.successful_requests