simforge-py 0.1.0__tar.gz

simforge_py-0.1.0/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: simforge-py
+Version: 0.1.0
+Summary: Simforge client for provider-based API calls
+Author: Harvest Team
+Requires-Python: >=3.11,<3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: minijinja (>=2.12.0,<3.0.0)
+Requires-Dist: openai (>=1.42.0,<2.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Description-Content-Type: text/markdown
+
+# Kirby
+
+Kirby client for provider-based API calls.
+
+## Installation
+
+For local development:
+
+```bash
+cd kirby
+poetry install
+```
+
+Or install as an editable package from the parent directory:
+
+```bash
+poetry add --editable ../kirby
+```
+
+## Usage
+
+```python
+from kirby import Kirby
+
+client = Kirby(
+    provider="openAI",
+    key="your-api-key",
+    model="gpt-4",
+    kirby_url="https://your-kirby-instance.com",  # Optional, can use KIRBY_URL env var
+    kirby_user_id="user-id",  # Optional, can use KIRBY_USER_ID env var
+)
+
+result = client.call("method_name", arg1="value1", arg2="value2")
+```
+
+## Configuration
+
+The `kirby_url` and `kirby_user_id` can be provided either:
+- As constructor arguments
+- As environment variables (`KIRBY_URL` and `KIRBY_USER_ID`)
+

simforge_py-0.1.0/README.md

@@ -0,0 +1,40 @@
+# Kirby
+
+Kirby client for provider-based API calls.
+
+## Installation
+
+For local development:
+
+```bash
+cd kirby
+poetry install
+```
+
+Or install as an editable package from the parent directory:
+
+```bash
+poetry add --editable ../kirby
+```
+
+## Usage
+
+```python
+from kirby import Kirby
+
+client = Kirby(
+    provider="openAI",
+    key="your-api-key",
+    model="gpt-4",
+    kirby_url="https://your-kirby-instance.com",  # Optional, can use KIRBY_URL env var
+    kirby_user_id="user-id",  # Optional, can use KIRBY_USER_ID env var
+)
+
+result = client.call("method_name", arg1="value1", arg2="value2")
+```
+
+## Configuration
+
+The `kirby_url` and `kirby_user_id` can be provided either:
+- As constructor arguments
+- As environment variables (`KIRBY_URL` and `KIRBY_USER_ID`)

simforge_py-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[tool.poetry]
+name = "simforge-py"
+version = "0.1.0"
+description = "Simforge client for provider-based API calls"
+authors = ["Harvest Team"]
+readme = "README.md"
+packages = [{include = "simforge"}]
+
+[tool.poetry.dependencies]
+python = ">=3.11,<3.13"
+requests = "^2.32.3"
+minijinja = "^2.12.0"
+openai = "^1.42.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 88
+target-version = ['py311']
+include = '\.pyi?$'
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+line_length = 88

simforge_py-0.1.0/simforge/__init__.py

@@ -0,0 +1,5 @@
+"""Kirby client for provider-based API calls."""
+
+from kirby.client import Kirby
+
+__all__ = ["Kirby"]

simforge_py-0.1.0/simforge/client.py

@@ -0,0 +1,165 @@
+"""Kirby client for provider-based API calls."""
+
+import logging
+from typing import Any, Optional
+
+import requests
+from minijinja import Environment
+from openai import OpenAI
+
+logger = logging.getLogger(__name__)
+
+
+class Kirby:
+    """Client for making provider-based API calls."""
+
+    def __init__(
+        self,
+        provider: str,
+        key: str,
+        model: str,
+        kirby_url: Optional[str] = None,
+        kirby_user_id: Optional[str] = None,
+    ):
+        """Initialize the Kirby client.
+
+        Args:
+            provider: The provider name (e.g., 'openAI')
+            key: The API key for the provider
+            model: The model name to use
+            kirby_url: The base URL for the Kirby API (can also be set via KIRBY_URL env var)
+            kirby_user_id: The user ID for Kirby API (can also be set via KIRBY_USER_ID env var)
+        """
+        self.provider = provider
+        self.key = key
+        self.model = model
+        self.kirby_url = kirby_url
+        self.kirby_user_id = kirby_user_id
+
+    def call(self, method_name: str, **kwargs: Any) -> Any:
+        """Call a method with the given arguments.
+
+        Args:
+            method_name: The name of the method to call
+            **kwargs: Keyword arguments to pass to the method
+
+        Returns:
+            The result of the OpenAI API call
+
+        Raises:
+            ValueError: If KIRBY_URL or KIRBY_USER_ID is not set, or if no prompt is found
+        """
+        import os
+
+        # Get kirby_url and kirby_user_id from instance or environment
+        kirby_url = self.kirby_url or os.getenv("KIRBY_URL")
+        kirby_user_id = self.kirby_user_id or os.getenv("KIRBY_USER_ID")
+
+        if not kirby_url:
+            raise ValueError(
+                "KIRBY_URL must be provided or set as environment variable"
+            )
+        if not kirby_user_id:
+            raise ValueError(
+                "KIRBY_USER_ID must be provided or set as environment variable"
+            )
+
+        # Call find_or_create endpoint
+        url = f"{kirby_url}/api/functions/find_or_create"
+        payload = {
+            "userId": kirby_user_id,
+            "name": method_name,
+            "variables": kwargs,
+        }
+
+        try:
+            response = requests.post(
+                url,
+                json=payload,
+                headers={"Content-Type": "application/json"},
+                timeout=30,
+            )
+            response.raise_for_status()
+            function_result = response.json()
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error calling Kirby endpoint: {e}")
+            if hasattr(e, "response") and e.response is not None:
+                logger.error(f"Response status: {e.response.status_code}")
+                logger.error(f"Response body: {e.response.text}")
+            raise
+
+        # Check if we have a version prompt
+        version_prompt = function_result.get("versionPrompt")
+        function_id = function_result.get("id")
+
+        if not version_prompt:
+            # Build the function URL
+            function_url = f"{kirby_url}/functions/{function_id}" if function_id else kirby_url
+            raise ValueError(
+                f"No prompt found for this function. Please add a prompt at: {function_url}"
+            )
+
+        # Get variables from the function result metadata and merge with kwargs
+        variables = function_result.get("metadata", {}).get("initialVariables", {})
+        # Merge with kwargs passed to the function
+        variables.update(kwargs)
+
+        # Template the prompt using minijinja
+        env = Environment()
+        templated_prompt = env.render_str(version_prompt, **variables)
+        logger.info(f"Templated prompt: {templated_prompt}")
+
+        # Call OpenAI with the templated prompt
+        openai_client = OpenAI(api_key=self.key)
+        completion = openai_client.chat.completions.create(
+            model=self.model,
+            messages=[{"role": "user", "content": templated_prompt}],
+        )
+
+        result = completion.choices[0].message.content
+
+        # Create trace with the result
+        function_version_id = function_result.get("versionId")
+        if function_version_id:
+            trace_url = f"{kirby_url}/api/functions/{function_id}/traces"
+            trace_payload = {
+                "functionVersionId": function_version_id,
+                "result": result,
+                "variables": variables,
+                "provider": self.provider.lower(),
+                "model": completion.model,
+                "usage": (
+                    completion.usage.model_dump()
+                    if hasattr(completion.usage, "model_dump")
+                    else (
+                        {
+                            "prompt_tokens": getattr(
+                                completion.usage, "prompt_tokens", 0
+                            ),
+                            "completion_tokens": getattr(
+                                completion.usage, "completion_tokens", 0
+                            ),
+                            "total_tokens": getattr(
+                                completion.usage, "total_tokens", 0
+                            ),
+                        }
+                        if completion.usage
+                        else {}
+                    )
+                ),
+            }
+
+            try:
+                trace_response = requests.post(
+                    trace_url,
+                    json=trace_payload,
+                    headers={"Content-Type": "application/json"},
+                    timeout=30,
+                )
+                trace_response.raise_for_status()
+                logger.info(f"Trace created: {trace_response.json().get('id')}")
+            except requests.exceptions.RequestException as e:
+                logger.warning(f"Failed to create trace: {e}")
+                # Don't fail the whole function call if trace creation fails
+
+        return result