impact 0.1__py3-none-any.whl

impact/__init__.py

@@ -0,0 +1,2 @@
+from impact.sdk import Impact
+__all__ = ["Impact"]

impact/sdk/__init__.py

@@ -0,0 +1,196 @@
+import os
+import sys
+from pathlib import Path
+
+from typing import Optional, Set
+from colorama import Fore
+from opentelemetry.sdk.trace import SpanProcessor
+from opentelemetry.sdk.trace.export import SpanExporter
+
+
+from opentelemetry.sdk.resources import SERVICE_NAME
+from opentelemetry.propagators.textmap import TextMapPropagator
+from opentelemetry.util.re import parse_env_headers
+
+from impact.sdk.images.image_uploader import ImageUploader
+
+
+from impact.sdk.telemetry import Telemetry
+from impact.sdk.instruments import Instruments
+from impact.sdk.config import (
+    is_content_tracing_enabled,
+    is_tracing_enabled,
+
+
+)
+from impact.sdk.fetcher import Fetcher
+from impact.sdk.tracing.tracing import (
+    TracerWrapper,
+    set_association_properties,
+    set_external_prompt_tracing_context,
+)
+from typing import Dict
+from impact.sdk.client.client import Client
+
+
+class Impact:
+    AUTO_CREATED_KEY_PATH = str(
+        Path.home() / ".cache" / "impact" / "auto_created_key"
+    )
+    AUTO_CREATED_URL = str(Path.home() / ".cache" / "impact" / "auto_created_url")
+
+    __tracer_wrapper: TracerWrapper
+    __fetcher: Optional[Fetcher] = None
+    __app_name: Optional[str] = None
+    __client: Optional[Client] = None
+
+    @staticmethod
+    def init(
+        app_name: str = sys.argv[0],
+        api_endpoint: str = "https://api.impact.ai",
+        api_key: Optional[str] = None,
+        enabled: bool = True,
+        headers: Dict[str, str] = {},
+        disable_batch=False,
+        telemetry_enabled: bool = False,
+        exporter: Optional[SpanExporter] = None,
+        
+        
+        
+        
+        processor: Optional[SpanProcessor] = None,
+        propagator: TextMapPropagator = None,
+        impact_sync_enabled: bool = False,
+        
+        resource_attributes: dict = {},
+        instruments: Optional[Set[Instruments]] = None,
+        block_instruments: Optional[Set[Instruments]] = None,
+        image_uploader: Optional[ImageUploader] = None,
+    ) -> Optional[Client]:
+        if not enabled:
+            TracerWrapper.set_disabled(True)
+            print(
+                Fore.YELLOW
+                + "Impact instrumentation is disabled via init flag"
+                + Fore.RESET
+            )
+            return
+
+        telemetry_enabled = (
+            telemetry_enabled
+            and (os.getenv("IMPACT_TELEMETRY") or "true").lower() == "true"
+        )
+        if telemetry_enabled:
+            Telemetry()
+
+        api_endpoint = os.getenv("IMPACT_BASE_URL") or api_endpoint
+        api_key = os.getenv("IMPACT_API_KEY") or api_key
+        Impact.__app_name = app_name
+
+        if not is_tracing_enabled():
+            print(Fore.YELLOW + "Tracing is disabled" + Fore.RESET)
+            return
+
+        enable_content_tracing = is_content_tracing_enabled()
+
+        if exporter or processor:
+            print(Fore.GREEN + "Impact exporting traces to a custom exporter")
+
+        headers = os.getenv("IMPACT_HEADERS") or headers
+
+        if isinstance(headers, str):
+            headers = parse_env_headers(headers)
+
+        if (
+            not exporter
+            and not processor
+            and api_endpoint == "https://api.impact.ai"
+            and not api_key
+        ):
+            print(
+                Fore.RED
+                + "Error: Missing Impact API key,"
+                + " go to https://app.impact.ai/settings/api-keys to create one"
+            )
+            print("Set the IMPACT_API_KEY environment variable to the key")
+            print(Fore.RESET)
+            return
+
+        if not exporter and not processor and headers:
+            print(
+                Fore.GREEN
+                + f"Impact exporting traces to {api_endpoint}, authenticating with custom headers"
+            )
+
+        if api_key and not exporter and not processor and not headers:
+            print(
+                Fore.GREEN
+                + f"Impact exporting traces to {api_endpoint} authenticating with bearer token"
+            )
+            headers = {
+                "Authorization": f"Bearer {api_key}",
+            }
+
+        print(Fore.RESET)
+
+        # Tracer init
+        resource_attributes.update({SERVICE_NAME: app_name})
+        TracerWrapper.set_static_params(
+            resource_attributes, enable_content_tracing, api_endpoint, headers
+        )
+        Impact.__tracer_wrapper = TracerWrapper(
+            disable_batch=disable_batch,
+            processor=processor,
+            propagator=propagator,
+            exporter=exporter,
+
+            image_uploader=image_uploader or ImageUploader(api_endpoint, api_key),
+            instruments=instruments,
+            block_instruments=block_instruments,
+        )
+
+
+
+        if (
+            api_endpoint.find("impact.ai") != -1
+            and api_key
+            and (exporter is None)
+            and (processor is None)
+        ):
+            if impact_sync_enabled:
+                Impact.__fetcher = Fetcher(base_url=api_endpoint, api_key=api_key)
+                Impact.__fetcher.run()
+                print(
+                    Fore.GREEN
+                    + "Impact syncing configuration and prompts"
+                    + Fore.RESET
+                )
+            Impact.__client = Client(
+                api_key=api_key, app_name=app_name, api_endpoint=api_endpoint
+            )
+            return Impact.__client
+
+    def set_association_properties(properties: dict) -> None:
+        set_association_properties(properties)
+
+    def set_prompt(template: str, variables: dict, version: int):
+        set_external_prompt_tracing_context(template, variables, version)
+
+    @staticmethod
+    def get():
+        """
+        Returns the shared SDK client instance, using the current global configuration.
+
+        To use the SDK as a singleton, first make sure you have called :func:`Impact.init()`
+        at startup time. Then ``get()`` will return the same shared :class:`Impact.client.Client`
+        instance each time. The client will be initialized if it has not been already.
+
+        If you need to create multiple client instances with different configurations, instead of this
+        singleton approach you can call the :class:`Impact.client.Client` constructor directly instead.
+        """
+        if not Impact.__client:
+            raise Exception(
+                "Client not initialized, you should call Impact.init() first. "
+                "If you are still getting this error - you are missing the api key"
+            )
+        return Impact.__client

impact/sdk/annotation/base_annotation.py

@@ -0,0 +1,71 @@
+from typing import Dict, Any
+
+from ..client.http import HTTPClient
+
+
+class BaseAnnotation:
+    """
+    Annotation class for creating annotations in Impact.
+
+    This class provides functionality to create annotations for specific tasks.
+    """
+
+    _http: HTTPClient
+    _app_name: str
+
+    def __init__(self, http: HTTPClient, app_name: str, flow: str):
+        self._http = http
+        self._app_name = app_name
+        self._flow = flow
+
+    def create(
+        self,
+        annotation_task: str,
+        entity_id: str,
+        tags: Dict[str, Any],
+    ) -> None:
+        """Create an user feedback annotation for a specific task.
+
+        Args:
+            annotation_task (str): The ID/slug of the annotation task to report to.
+                Can be found at app.impact.ai/annotation_tasks/:annotation_task_id
+            entity_id (str): The ID of the specific entity instance being annotated, should be reported
+                in the association properties
+            tags (Dict[str, Any]): Dictionary containing the tags to be reported.
+                Should match the tags defined in the annotation task
+
+        Example:
+            ```python
+            client = Client(api_key="your-key")
+            client.annotation.create(
+                annotation_task="task_123",
+                entity_id="instance_456",
+                tags={
+                    "sentiment": "positive",
+                    "relevance": 0.95,
+                    "tones": ["happy", "nice"]
+                },
+            )
+            ```
+        """
+
+        if not annotation_task:
+            raise ValueError("annotation_task is required")
+        if not entity_id:
+            raise ValueError("entity_id is required")
+        if not tags:
+            raise ValueError("tags cannot be empty")
+
+        self._http.post(
+            f"annotation-tasks/{annotation_task}/annotations",
+            {
+                "entity_instance_id": entity_id,
+                "tags": tags,
+                "source": "sdk",
+                "flow": self._flow,
+                "actor": {
+                    "type": "service",
+                    "id": self._app_name,
+                },
+            },
+        )

impact/sdk/annotation/user_feedback.py

@@ -0,0 +1,43 @@
+from typing import Any, Dict
+
+from impact.sdk.client.http import HTTPClient
+from .base_annotation import BaseAnnotation
+
+
+class UserFeedback(BaseAnnotation):
+    def __init__(self, http: HTTPClient, app_name: str):
+        super().__init__(http, app_name, "user_feedback")
+
+
+def create(
+    self,
+    annotation_task: str,
+    entity_instance_id: str,
+    tags: Dict[str, Any],
+) -> None:
+    """Create an annotation for a specific task.
+
+    Args:
+        annotation_task (str): The ID/slug of the annotation task to report to.
+            Can be found at app.impact.ai/annotation_tasks/:annotation_task_id
+        entity_instance_id (str): The ID of the specific entity instance being annotated, should be reported
+            in the association properties
+        tags (Dict[str, Any]): Dictionary containing the tags to be reported.
+            Should match the tags defined in the annotation task
+
+    Example:
+        ```python
+        client = Client(api_key="your-key")
+        client.annotation.create(
+            annotation_task="task_123",
+            entity_instance_id="instance_456",
+            tags={
+                "sentiment": "positive",
+                "relevance": 0.95,
+                "tones": ["happy", "nice"]
+            },
+        )
+        ```
+    """
+
+    return BaseAnnotation.create(self, annotation_task, entity_instance_id, tags)

impact/sdk/client/__init__.py

@@ -0,0 +1 @@
+from .client import Client

impact/sdk/client/client.py

@@ -0,0 +1,40 @@
+import sys
+
+from impact.sdk.annotation.user_feedback import UserFeedback
+from .http import HTTPClient
+from impact.sdk.version import __version__
+
+
+class Client:
+    """
+    Impact Client for interacting with the Impact API.
+
+    Applications should configure the client at startup time and continue to use it throughout the lifetime
+    of the application, rather than creating instances on the fly. The best way to do this is with the
+    singleton methods :func:`Impact.init()` and :func:`Impact.get()`. However, you may also call
+    the constructor directly if you need to maintain multiple instances.
+    """
+
+    app_name: str
+    api_endpoint: str
+    api_key: str
+    user_feedback: UserFeedback
+    _http: HTTPClient
+
+    def __init__(self, api_key: str, app_name: str = sys.argv[0], api_endpoint: str = "https://api.impact.ai"):
+        """
+        Initialize a new Impact client.
+
+        Args:
+            api_key (str): Your Impact API key
+            app_name (Optional[str], optional): The name of your application. Defaults to sys.argv[0].
+            api_endpoint (Optional[str], optional): Custom API endpoint. Defaults to https://api.impact.ai.
+        """
+        if not api_key or not api_key.strip():
+            raise ValueError("API key is required")
+
+        self.app_name = app_name
+        self.api_endpoint = api_endpoint or "https://api.impact.ai"
+        self.api_key = api_key
+        self._http = HTTPClient(base_url=self.api_endpoint, api_key=self.api_key, version=__version__)
+        self.user_feedback = UserFeedback(self._http, self.app_name)

impact/sdk/client/http.py

@@ -0,0 +1,45 @@
+from typing import Any, Dict, Optional
+
+import requests
+from colorama import Fore
+
+
+class HTTPClient:
+    base_url: str
+    api_key: str
+    version: str
+
+    def __init__(self, base_url: str, api_key: str, version: str):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.version = version
+
+    def _headers(self):
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "X-Impact-SDK-Version": self.version,
+        }
+
+    def post(self, path: str, data: Dict[str, Any]) -> Any:
+        """
+        Make a POST request to the API
+        """
+        try:
+            response = requests.post(f"{self.base_url}/v2/{path.lstrip('/')}", json=data, headers=self._headers())
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            print(Fore.RED + f"Error making request to {path}: {str(e)}" + Fore.RESET)
+            return None
+
+    def get(self, path: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        """
+        Make a GET request to the API
+        """
+        try:
+            response = requests.get(f"{self.base_url}/v2/{path.lstrip('/')}", params=params, headers=self._headers())
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            print(Fore.RED + f"Error making request to {path}: {str(e)}" + Fore.RESET)
+            return None

impact/sdk/config/__init__.py

@@ -0,0 +1,13 @@
+import os
+
+
+def is_tracing_enabled() -> bool:
+    return (os.getenv("IMPACT_TRACING_ENABLED") or "true").lower() == "true"
+
+
+def is_content_tracing_enabled() -> bool:
+    return (os.getenv("IMPACT_TRACE_CONTENT") or "true").lower() == "true"
+
+
+
+

impact/sdk/decorators/__init__.py

@@ -0,0 +1,149 @@
+from typing import Optional
+import warnings
+
+from opentelemetry.semconv_ai import ImpactSpanKindValues
+
+from impact.sdk.decorators.base import (
+    entity_class,
+    entity_method,
+)
+
+
+def task(
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    method_name: Optional[str] = None,
+    tlp_span_kind: Optional[ImpactSpanKindValues] = ImpactSpanKindValues.TASK,
+):
+    if method_name is None:
+        return entity_method(name=name, version=version, tlp_span_kind=tlp_span_kind)
+    else:
+        return entity_class(
+            name=name,
+            version=version,
+            method_name=method_name,
+            tlp_span_kind=tlp_span_kind,
+        )
+
+
+def workflow(
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    method_name: Optional[str] = None,
+    tlp_span_kind: Optional[ImpactSpanKindValues] = ImpactSpanKindValues.WORKFLOW,
+):
+    if method_name is None:
+        return entity_method(name=name, version=version, tlp_span_kind=tlp_span_kind)
+    else:
+        return entity_class(
+            name=name,
+            version=version,
+            method_name=method_name,
+            tlp_span_kind=tlp_span_kind,
+        )
+
+
+def agent(
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    method_name: Optional[str] = None,
+):
+    return workflow(
+        name=name,
+        version=version,
+        method_name=method_name,
+        tlp_span_kind=ImpactSpanKindValues.AGENT,
+    )
+
+
+def tool(
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    method_name: Optional[str] = None,
+):
+    return task(
+        name=name,
+        version=version,
+        method_name=method_name,
+        tlp_span_kind=ImpactSpanKindValues.TOOL,
+    )
+
+
+# Async Decorators - Deprecated
+def atask(
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    method_name: Optional[str] = None,
+    tlp_span_kind: Optional[ImpactSpanKindValues] = ImpactSpanKindValues.TASK,
+):
+    warnings.warn(
+        "DeprecationWarning: The @atask decorator will be removed in a future version. "
+        "Please migrate to @task for both sync and async operations.",
+        DeprecationWarning,
+        stacklevel=2
+    )
+    if method_name is None:
+        return entity_method(name=name, version=version, tlp_span_kind=tlp_span_kind)
+    else:
+        return entity_class(name=name, version=version, method_name=method_name, tlp_span_kind=tlp_span_kind)
+
+
+def aworkflow(
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    method_name: Optional[str] = None,
+    tlp_span_kind: Optional[ImpactSpanKindValues] = ImpactSpanKindValues.WORKFLOW,
+):
+    warnings.warn(
+        "DeprecationWarning: The @aworkflow decorator will be removed in a future version. "
+        "Please migrate to @workflow for both sync and async operations.",
+        DeprecationWarning,
+        stacklevel=2
+    )
+    if method_name is None:
+        return entity_method(name=name, version=version, tlp_span_kind=tlp_span_kind)
+    else:
+        return entity_class(
+            name=name,
+            version=version,
+            method_name=method_name,
+            tlp_span_kind=tlp_span_kind,
+        )
+
+
+def aagent(
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    method_name: Optional[str] = None,
+):
+    warnings.warn(
+        "DeprecationWarning: The @aagent decorator will be removed in a future version. "
+        "Please migrate to @agent for both sync and async operations.",
+        DeprecationWarning,
+        stacklevel=2
+    )
+    return atask(
+        name=name,
+        version=version,
+        method_name=method_name,
+        tlp_span_kind=ImpactSpanKindValues.AGENT,
+    )
+
+
+def atool(
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    method_name: Optional[str] = None,
+):
+    warnings.warn(
+        "DeprecationWarning: The @atool decorator will be removed in a future version. "
+        "Please migrate to @tool for both sync and async operations.",
+        DeprecationWarning,
+        stacklevel=2
+    )
+    return atask(
+        name=name,
+        version=version,
+        method_name=method_name,
+        tlp_span_kind=ImpactSpanKindValues.TOOL,
+    )