intentkit 0.6.13.dev2__py3-none-any.whl → 0.8.17__py3-none-any.whl

intentkit/skills/venice_image/__init__.py

@@ -1,154 +1,147 @@
-import logging
-from typing import NotRequired, Optional, TypedDict
-
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.skills.base import (
-    SkillConfig,
-    SkillState,
-)
-
-# Import the base tool and all specific model skill classes
-from intentkit.skills.venice_image.base import VeniceImageBaseTool
-from intentkit.skills.venice_image.image_enhance.image_enhance import ImageEnhance
-from intentkit.skills.venice_image.image_generation.image_generation_fluently_xl import (
-    ImageGenerationFluentlyXL,
-)
-from intentkit.skills.venice_image.image_generation.image_generation_flux_dev import (
-    ImageGenerationFluxDev,
-)
-from intentkit.skills.venice_image.image_generation.image_generation_flux_dev_uncensored import (
-    ImageGenerationFluxDevUncensored,
-)
-from intentkit.skills.venice_image.image_generation.image_generation_lustify_sdxl import (
-    ImageGenerationLustifySDXL,
-)
-from intentkit.skills.venice_image.image_generation.image_generation_pony_realism import (
-    ImageGenerationPonyRealism,
-)
-from intentkit.skills.venice_image.image_generation.image_generation_stable_diffusion_3_5 import (
-    ImageGenerationStableDiffusion35,
-)
-from intentkit.skills.venice_image.image_generation.image_generation_venice_sd35 import (
-    ImageGenerationVeniceSD35,
-)
-from intentkit.skills.venice_image.image_upscale.image_upscale import ImageUpscale
-from intentkit.skills.venice_image.image_vision.image_vision import ImageVision
-
-# Cache skills at the system level, because they are stateless and only depend on the store
-_cache: dict[str, VeniceImageBaseTool] = {}
-
-logger = logging.getLogger(__name__)
-
-
-# Define the expected structure for the 'states' dictionary in the config
-class SkillStates(TypedDict):
-    image_upscale: SkillState
-    image_enhance: SkillState
-    image_vision: SkillState
-    image_generation_flux_dev: SkillState
-    image_generation_flux_dev_uncensored: SkillState
-    image_generation_venice_sd35: SkillState
-    image_generation_fluently_xl: SkillState
-    image_generation_lustify_sdxl: SkillState
-    image_generation_pony_realism: SkillState
-    image_generation_stable_diffusion_3_5: SkillState
-    # Add new skill names here if more models are added
-
-
-# Define the overall configuration structure for the venice_image category
-class Config(SkillConfig):
-    """Configuration for Venice Image skills."""
-
-    enabled: bool  # Keep standard enabled flag
-    states: SkillStates
-    api_key_provider: str = "agent_owner"
-    api_key: NotRequired[Optional[str]]  # Explicitly Optional
-    safe_mode: NotRequired[bool]  # Defaults handled in base or usage
-    hide_watermark: NotRequired[bool]  # Defaults handled in base or usage
-    negative_prompt: NotRequired[str]  # Defaults handled in base or usage
-    rate_limit_number: NotRequired[Optional[int]]  # Explicitly Optional
-    rate_limit_minutes: NotRequired[Optional[int]]  # Explicitly Optional
-
-
-_SKILL_NAME_TO_CLASS_MAP: dict[str, type[VeniceImageBaseTool]] = {
-    "image_upscale": ImageUpscale,
-    "image_enhance": ImageEnhance,
-    "image_vision": ImageVision,
-    "image_generation_flux_dev": ImageGenerationFluxDev,
-    "image_generation_flux_dev_uncensored": ImageGenerationFluxDevUncensored,
-    "image_generation_venice_sd35": ImageGenerationVeniceSD35,
-    "image_generation_fluently_xl": ImageGenerationFluentlyXL,
-    "image_generation_lustify_sdxl": ImageGenerationLustifySDXL,
-    "image_generation_pony_realism": ImageGenerationPonyRealism,
-    "image_generation_stable_diffusion_3_5": ImageGenerationStableDiffusion35,
-}
-
-
-async def get_skills(
-    config: "Config",
-    is_private: bool,
-    store: SkillStoreABC,
-    **_,  # Allow for extra arguments if the loader passes them
-) -> list[VeniceImageBaseTool]:
-    """Get all enabled Venice Image skills based on configuration and privacy level.
-
-    Args:
-        config: The configuration for Venice Image skills.
-        is_private: Whether the context is private (e.g., agent owner).
-        store: The skill store for persisting data and accessing system config.
-
-    Returns:
-        A list of instantiated and enabled Venice Image skill objects.
-    """
-    # Check if the entire category is disabled first
-    if not config.get("enabled", False):
-        return []
-
-    available_skills: list[VeniceImageBaseTool] = []
-
-    # Include skills based on their state
-    for skill_name, state in config["states"].items():
-        if state == "disabled":
-            continue
-        elif state == "public" or (state == "private" and is_private):
-            available_skills.append(skill_name)
-
-    # Get each skill using the cached getter
-    result = []
-    for name in available_skills:
-        skill = get_venice_image_skill(name, store, config)
-        if skill:
-            result.append(skill)
-    return result
-
-
-def get_venice_image_skill(
-    name: str,
-    store: SkillStoreABC,
-    config: "Config",
-) -> Optional[VeniceImageBaseTool]:
-    """
-    Factory function to get a cached Venice Image skill instance by name.
-
-    Args:
-        name: The name of the skill to get (must match keys in _SKILL_NAME_TO_CLASS_MAP).
-        store: The skill store, passed to the skill constructor.
-
-    Returns:
-        The requested Venice Image skill instance, or None if the name is unknown.
-    """
-
-    # Return from cache immediately if already exists
-    if name in _cache:
-        return _cache[name]
-
-    skill_class = _SKILL_NAME_TO_CLASS_MAP.get(name)
-    if not skill_class:
-        logger.warning(f"Unknown Venice skill: {name}")
-        return None
-
-    # Cache and return the newly created instance
-    _cache[name] = skill_class(
-        skill_store=store,
-    )
-    return _cache[name]
+import logging
+from typing import NotRequired, TypedDict
+
+from intentkit.skills.base import (
+    SkillConfig,
+    SkillState,
+)
+
+# Import the base tool and all specific model skill classes
+from intentkit.skills.venice_image.base import VeniceImageBaseTool
+from intentkit.skills.venice_image.image_enhance.image_enhance import ImageEnhance
+from intentkit.skills.venice_image.image_generation.image_generation_fluently_xl import (
+    ImageGenerationFluentlyXL,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_flux_dev import (
+    ImageGenerationFluxDev,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_flux_dev_uncensored import (
+    ImageGenerationFluxDevUncensored,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_lustify_sdxl import (
+    ImageGenerationLustifySDXL,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_pony_realism import (
+    ImageGenerationPonyRealism,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_stable_diffusion_3_5 import (
+    ImageGenerationStableDiffusion35,
+)
+from intentkit.skills.venice_image.image_generation.image_generation_venice_sd35 import (
+    ImageGenerationVeniceSD35,
+)
+from intentkit.skills.venice_image.image_upscale.image_upscale import ImageUpscale
+from intentkit.skills.venice_image.image_vision.image_vision import ImageVision
+
+# Cache skills at the system level, because they are stateless and only depend on the store
+_cache: dict[str, VeniceImageBaseTool] = {}
+
+logger = logging.getLogger(__name__)
+
+
+# Define the expected structure for the 'states' dictionary in the config
+class SkillStates(TypedDict):
+    image_upscale: SkillState
+    image_enhance: SkillState
+    image_vision: SkillState
+    image_generation_flux_dev: SkillState
+    image_generation_flux_dev_uncensored: SkillState
+    image_generation_venice_sd35: SkillState
+    image_generation_fluently_xl: SkillState
+    image_generation_lustify_sdxl: SkillState
+    image_generation_pony_realism: SkillState
+    image_generation_stable_diffusion_3_5: SkillState
+    # Add new skill names here if more models are added
+
+
+# Define the overall configuration structure for the venice_image category
+class Config(SkillConfig):
+    """Configuration for Venice Image skills."""
+
+    enabled: bool  # Keep standard enabled flag
+    states: SkillStates
+    api_key_provider: str = "agent_owner"
+    api_key: NotRequired[str | None]  # Explicitly Optional
+    safe_mode: NotRequired[bool]  # Defaults handled in base or usage
+    hide_watermark: NotRequired[bool]  # Defaults handled in base or usage
+    negative_prompt: NotRequired[str]  # Defaults handled in base or usage
+    rate_limit_number: NotRequired[int | None]  # Explicitly Optional
+    rate_limit_minutes: NotRequired[int | None]  # Explicitly Optional
+
+
+_SKILL_NAME_TO_CLASS_MAP: dict[str, type[VeniceImageBaseTool]] = {
+    "image_upscale": ImageUpscale,
+    "image_enhance": ImageEnhance,
+    "image_vision": ImageVision,
+    "image_generation_flux_dev": ImageGenerationFluxDev,
+    "image_generation_flux_dev_uncensored": ImageGenerationFluxDevUncensored,
+    "image_generation_venice_sd35": ImageGenerationVeniceSD35,
+    "image_generation_fluently_xl": ImageGenerationFluentlyXL,
+    "image_generation_lustify_sdxl": ImageGenerationLustifySDXL,
+    "image_generation_pony_realism": ImageGenerationPonyRealism,
+    "image_generation_stable_diffusion_3_5": ImageGenerationStableDiffusion35,
+}
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    **_,  # Allow for extra arguments if the loader passes them
+) -> list[VeniceImageBaseTool]:
+    """Get all enabled Venice Image skills based on configuration and privacy level.
+
+    Args:
+        config: The configuration for Venice Image skills.
+        is_private: Whether the context is private (e.g., agent owner).
+
+    Returns:
+        A list of instantiated and enabled Venice Image skill objects.
+    """
+    # Check if the entire category is disabled first
+    if not config.get("enabled", False):
+        return []
+
+    available_skills: list[VeniceImageBaseTool] = []
+
+    # Include skills based on their state
+    for skill_name, state in config["states"].items():
+        if state == "disabled":
+            continue
+        elif state == "public" or (state == "private" and is_private):
+            available_skills.append(skill_name)
+
+    # Get each skill using the cached getter
+    result = []
+    for name in available_skills:
+        skill = get_venice_image_skill(name, config)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def get_venice_image_skill(
+    name: str,
+    config: "Config",
+) -> VeniceImageBaseTool | None:
+    """
+    Factory function to get a cached Venice Image skill instance by name.
+
+    Args:
+        name: The name of the skill to get (must match keys in _SKILL_NAME_TO_CLASS_MAP).
+
+    Returns:
+        The requested Venice Image skill instance, or None if the name is unknown.
+    """
+
+    # Return from cache immediately if already exists
+    if name in _cache:
+        return _cache[name]
+
+    skill_class = _SKILL_NAME_TO_CLASS_MAP.get(name)
+    if not skill_class:
+        logger.warning(f"Unknown Venice skill: {name}")
+        return None
+
+    # Cache and return the newly created instance
+    _cache[name] = skill_class()
+    return _cache[name]

intentkit/skills/venice_image/api.py

@@ -1,138 +1,138 @@
-"""
-This module encapsulates all interactions with the Venice AI API.
-It provides a function, make_venice_api_request, to make POST requests
-to the API and handles the responses, including error handling,
-content type checking, and image storage via S3.  This separation
-of concerns keeps the core skill logic cleaner and easier to maintain.
-"""
-
-import hashlib
-import logging
-from typing import Any, Dict, Optional, Tuple
-
-import httpx
-
-from intentkit.utils.s3 import store_image_bytes
-
-logger = logging.getLogger(__name__)
-
-
-async def make_venice_api_request(
-    api_key: str,
-    path: str,
-    payload: Dict[str, Any],
-    category: str,
-    tool_name: str,
-) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
-    """
-    Makes a POST request to the Venice AI API, handling all aspects
-    of the API interaction.  This includes:
-
-    1.  Constructing the API URL using a base URL and the provided path.
-    2.  Adding the required authorization header with the provided API key.
-    3.  Sending the POST request with the given payload.
-    4.  Handling potential connection and HTTP errors.
-    5.  Calling the internal _handle_response function to process the API's
-        response, which might be JSON or an image.
-
-    Args:
-        api_key: The Venice AI API key for authentication.
-        path: The API endpoint path (e.g., "/api/v1/image/generate").  Should *not* start with the base URL.
-        payload: The data to send in the request body (as JSON).
-        category: The category of the skill making the request (e.g., "venice_image"). Used for S3 storage and logging purpose.
-        tool_name: The name of the tool or skill making the request (e.g., "image_generation"). Used for S3 storage and logging purpose.
-
-    Returns:
-        A tuple: (success_data, error_data).
-        - success_data:  A dictionary containing the parsed JSON response from the API if the request was successful
-          (or a dictionary containing the S3 URL if the response is an image).
-        - error_data:  A dictionary containing information about any errors that occurred,
-          or None if the request was successful.  The dictionary includes an 'error' key.
-    """
-
-    venice_base_url = "https://api.venice.ai"  # Venice AI API base URL
-
-    if not path.startswith("/"):
-        path = "/" + path
-
-    api_url = f"{venice_base_url}{path}"
-
-    headers = {
-        "Authorization": f"Bearer {api_key}",
-        "Content-Type": "application/json",
-        "Accept": "image/*, application/json",
-    }
-
-    logger.info(
-        f"[{category}/{tool_name}] Sending request to {api_url} with payload: {payload}"
-    )
-
-    try:
-        async with httpx.AsyncClient(timeout=180.0) as client:
-            response = await client.post(api_url, json=payload, headers=headers)
-            return await _handle_response(response, category, tool_name)
-
-    except httpx.RequestError as e:
-        error_msg = f"Connection error: {e}"
-        logger.error(f"[{category}/{tool_name}] {error_msg}")
-        return {}, {"success": False, "error": error_msg}
-    except Exception as e:
-        error_msg = f"Unexpected error: {e}"
-        logger.error(f"[{category}/{tool_name}] {error_msg}", exc_info=True)
-        return {}, {"success": False, "error": error_msg}
-
-
-async def _handle_response(
-    response: httpx.Response, category: str, tool_name: str
-) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
-    """
-    Handles the API response, differentiating between JSON and image responses.
-
-    If the response is an image (based on the 'content-type' header),
-    it stores the image in S3 and returns the S3 URL.
-    If the response is JSON, it parses the JSON and returns it.
-    If any errors occur, it returns an error dictionary.
-    """
-
-    content_type = str(response.headers.get("content-type", "")).lower()
-
-    if response.status_code == 200 and content_type.startswith("image/"):
-        try:
-            upscaled_image_bytes = response.content
-            image_hash = hashlib.sha256(upscaled_image_bytes).hexdigest()
-            file_extension = content_type.split("/")[-1].split("+")[0] or "png"
-
-            key = f"{category}/{tool_name}/{image_hash}.{file_extension}"
-
-            logger.info(f"[{category}/{tool_name}] Storing image with key: {key}")
-
-            stored_url = await store_image_bytes(
-                upscaled_image_bytes, key, content_type=content_type
-            )
-
-            return {"success": True, "result": stored_url}, None
-
-        except Exception as e:
-            error_msg = f"Error processing image response: {e}"
-            logger.error(f"[{category}/{tool_name}] {error_msg}", exc_info=True)
-            return {}, {"success": False, "error": error_msg}
-
-    elif response.status_code == 200:
-        try:
-            logger.info(f"[{category}/{tool_name}] Received successful JSON response.")
-            return response.json(), None
-        except Exception as json_err:
-            error_msg = f"Failed to parse JSON response: {json_err} - {response.text}"
-            logger.error(f"[{category}/{tool_name}] {error_msg}")
-            return {}, {"success": False, "error": error_msg}
-
-    else:
-        try:
-            error_data = response.json()
-            error_msg = f"API returned error: {error_data.get('message', error_data.get('detail', response.text))}"
-            logger.error(f"[{category}/{tool_name}] {error_msg}")
-            return {}, {"success": False, "error": error_msg}
-        except Exception:
-            error_msg = f"API returned status code {response.status_code} with text: {response.text}"
-            logger.error(f"[{category}/{tool_name}] {error_msg}")
-            return {}, {"success": False, "error": error_msg}
+"""
+This module encapsulates all interactions with the Venice AI API.
+It provides a function, make_venice_api_request, to make POST requests
+to the API and handles the responses, including error handling,
+content type checking, and image storage via S3.  This separation
+of concerns keeps the core skill logic cleaner and easier to maintain.
+"""
+
+import hashlib
+import logging
+from typing import Any
+
+import httpx
+
+from intentkit.utils.s3 import store_image_bytes
+
+logger = logging.getLogger(__name__)
+
+
+async def make_venice_api_request(
+    api_key: str,
+    path: str,
+    payload: dict[str, Any],
+    category: str,
+    tool_name: str,
+) -> tuple[dict[str, Any], dict[str, Any] | None]:
+    """
+    Makes a POST request to the Venice AI API, handling all aspects
+    of the API interaction.  This includes:
+
+    1.  Constructing the API URL using a base URL and the provided path.
+    2.  Adding the required authorization header with the provided API key.
+    3.  Sending the POST request with the given payload.
+    4.  Handling potential connection and HTTP errors.
+    5.  Calling the internal _handle_response function to process the API's
+        response, which might be JSON or an image.
+
+    Args:
+        api_key: The Venice AI API key for authentication.
+        path: The API endpoint path (e.g., "/api/v1/image/generate").  Should *not* start with the base URL.
+        payload: The data to send in the request body (as JSON).
+        category: The category of the skill making the request (e.g., "venice_image"). Used for S3 storage and logging purpose.
+        tool_name: The name of the tool or skill making the request (e.g., "image_generation"). Used for S3 storage and logging purpose.
+
+    Returns:
+        A tuple: (success_data, error_data).
+        - success_data:  A dictionary containing the parsed JSON response from the API if the request was successful
+          (or a dictionary containing the S3 URL if the response is an image).
+        - error_data:  A dictionary containing information about any errors that occurred,
+          or None if the request was successful.  The dictionary includes an 'error' key.
+    """
+
+    venice_base_url = "https://api.venice.ai"  # Venice AI API base URL
+
+    if not path.startswith("/"):
+        path = "/" + path
+
+    api_url = f"{venice_base_url}{path}"
+
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+        "Accept": "image/*, application/json",
+    }
+
+    logger.info(
+        f"[{category}/{tool_name}] Sending request to {api_url} with payload: {payload}"
+    )
+
+    try:
+        async with httpx.AsyncClient(timeout=180.0) as client:
+            response = await client.post(api_url, json=payload, headers=headers)
+            return await _handle_response(response, category, tool_name)
+
+    except httpx.RequestError as e:
+        error_msg = f"Connection error: {e}"
+        logger.error(f"[{category}/{tool_name}] {error_msg}")
+        return {}, {"success": False, "error": error_msg}
+    except Exception as e:
+        error_msg = f"Unexpected error: {e}"
+        logger.error(f"[{category}/{tool_name}] {error_msg}", exc_info=True)
+        return {}, {"success": False, "error": error_msg}
+
+
+async def _handle_response(
+    response: httpx.Response, category: str, tool_name: str
+) -> tuple[dict[str, Any], dict[str, Any] | None]:
+    """
+    Handles the API response, differentiating between JSON and image responses.
+
+    If the response is an image (based on the 'content-type' header),
+    it stores the image in S3 and returns the S3 URL.
+    If the response is JSON, it parses the JSON and returns it.
+    If any errors occur, it returns an error dictionary.
+    """
+
+    content_type = str(response.headers.get("content-type", "")).lower()
+
+    if response.status_code == 200 and content_type.startswith("image/"):
+        try:
+            upscaled_image_bytes = response.content
+            image_hash = hashlib.sha256(upscaled_image_bytes).hexdigest()
+            file_extension = content_type.split("/")[-1].split("+")[0] or "png"
+
+            key = f"{category}/{tool_name}/{image_hash}.{file_extension}"
+
+            logger.info(f"[{category}/{tool_name}] Storing image with key: {key}")
+
+            stored_url = await store_image_bytes(
+                upscaled_image_bytes, key, content_type=content_type
+            )
+
+            return {"success": True, "result": stored_url}, None
+
+        except Exception as e:
+            error_msg = f"Error processing image response: {e}"
+            logger.error(f"[{category}/{tool_name}] {error_msg}", exc_info=True)
+            return {}, {"success": False, "error": error_msg}
+
+    elif response.status_code == 200:
+        try:
+            logger.info(f"[{category}/{tool_name}] Received successful JSON response.")
+            return response.json(), None
+        except Exception as json_err:
+            error_msg = f"Failed to parse JSON response: {json_err} - {response.text}"
+            logger.error(f"[{category}/{tool_name}] {error_msg}")
+            return {}, {"success": False, "error": error_msg}
+
+    else:
+        try:
+            error_data = response.json()
+            error_msg = f"API returned error: {error_data.get('message', error_data.get('detail', response.text))}"
+            logger.error(f"[{category}/{tool_name}] {error_msg}")
+            return {}, {"success": False, "error": error_msg}
+        except Exception:
+            error_msg = f"API returned status code {response.status_code} with text: {response.text}"
+            logger.error(f"[{category}/{tool_name}] {error_msg}")
+            return {}, {"success": False, "error": error_msg}