intentkit 0.6.9.dev2__py3-none-any.whl → 0.6.10.dev2__py3-none-any.whl

intentkit/skills/venice_image/image_enhance/image_enhance.py

@@ -1,80 +1,78 @@
-import logging
-from typing import Optional
-
-from langchain_core.runnables import RunnableConfig
-from pydantic import HttpUrl
-
-from intentkit.skills.base import ToolException
-from intentkit.skills.venice_image.image_enhance.image_enhance_base import (
-    VeniceImageEnhanceBaseTool,
-)
-from intentkit.skills.venice_image.utils import fetch_image_as_base64
-
-logger = logging.getLogger(__name__)
-
-
-class ImageEnhance(VeniceImageEnhanceBaseTool):
-    """
-    Enhances an existing image provided via URL using the Venice AI enhancer (not upscaling).
-    Useful for improving visual quality, adding style, or refining image features.
-    """
-
-    name: str = "venice_image_enhance"
-    description: str = (
-        "Enhances an existing image from a URL using Venice AI.\n"
-        "Provide the public URL of the image to enhance.\n"
-        "Specify enhancement creativity level and a required prompt for style.\n"
-        "Returns the URL of the enhanced image."
-    )
-
-    async def _arun(
-        self,
-        image_url: HttpUrl,
-        enhancePrompt: str,
-        replication: Optional[float] = 0.35,
-        enhanceCreativity: Optional[float] = 0.5,
-        config: RunnableConfig = None,
-        **kwargs,
-    ) -> dict:
-        """
-        Applies AI enhancement to an image without changing its size.
-        """
-
-        try:
-            context = self.context_from_config(config)
-
-            await self.apply_venice_rate_limit(context)
-
-            image_base64 = await fetch_image_as_base64(image_url)
-            if not image_base64:
-                error_msg = f"Failed to fetch or validate image from URL: {image_url}"
-                logger.error(error_msg)
-                raise ToolException(
-                    str({"success": False, "error": error_msg, "result": None})
-                )
-
-            payload = {
-                "image": image_base64,
-                "scale": 1,
-                "enhance": True,
-                "replication": replication,
-                "enhanceCreativity": enhanceCreativity,
-                "enhancePrompt": enhancePrompt,
-            }
-
-            result, error = await self.post("api/v1/image/upscale", payload, context)
-            if error:
-                raise ToolException(f"Venice Image Enhance API error: {error}")
-            return result
-        except ToolException as e:
-            raise e
-        except Exception as e:
-            logger.error(f"Error in {self.name}: {str(e)}")
-            raise ToolException(
-                str(
-                    {
-                        "success": False,
-                        "error": f"An unexpected error occurred: {str(e)}",
-                    }
-                )
-            )
+import logging
+from typing import Optional
+
+from pydantic import HttpUrl
+
+from intentkit.skills.base import ToolException
+from intentkit.skills.venice_image.image_enhance.image_enhance_base import (
+    VeniceImageEnhanceBaseTool,
+)
+from intentkit.skills.venice_image.utils import fetch_image_as_base64
+
+logger = logging.getLogger(__name__)
+
+
+class ImageEnhance(VeniceImageEnhanceBaseTool):
+    """
+    Enhances an existing image provided via URL using the Venice AI enhancer (not upscaling).
+    Useful for improving visual quality, adding style, or refining image features.
+    """
+
+    name: str = "venice_image_enhance"
+    description: str = (
+        "Enhances an existing image from a URL using Venice AI.\n"
+        "Provide the public URL of the image to enhance.\n"
+        "Specify enhancement creativity level and a required prompt for style.\n"
+        "Returns the URL of the enhanced image."
+    )
+
+    async def _arun(
+        self,
+        image_url: HttpUrl,
+        enhancePrompt: str,
+        replication: Optional[float] = 0.35,
+        enhanceCreativity: Optional[float] = 0.5,
+        **kwargs,
+    ) -> dict:
+        """
+        Applies AI enhancement to an image without changing its size.
+        """
+
+        try:
+            context = self.get_context()
+
+            await self.apply_venice_rate_limit(context)
+
+            image_base64 = await fetch_image_as_base64(image_url)
+            if not image_base64:
+                error_msg = f"Failed to fetch or validate image from URL: {image_url}"
+                logger.error(error_msg)
+                raise ToolException(
+                    str({"success": False, "error": error_msg, "result": None})
+                )
+
+            payload = {
+                "image": image_base64,
+                "scale": 1,
+                "enhance": True,
+                "replication": replication,
+                "enhanceCreativity": enhanceCreativity,
+                "enhancePrompt": enhancePrompt,
+            }
+
+            result, error = await self.post("api/v1/image/upscale", payload, context)
+            if error:
+                raise ToolException(f"Venice Image Enhance API error: {error}")
+            return result
+        except ToolException as e:
+            raise e
+        except Exception as e:
+            logger.error(f"Error in {self.name}: {str(e)}")
+            raise ToolException(
+                str(
+                    {
+                        "success": False,
+                        "error": f"An unexpected error occurred: {str(e)}",
+                    }
+                )
+            )

intentkit/skills/venice_image/image_generation/image_generation_base.py

@@ -1,117 +1,115 @@
-import base64
-import hashlib
-import logging
-from typing import Any, Dict, Literal, Optional, Type
-
-from langchain_core.runnables import RunnableConfig
-from pydantic import BaseModel, Field
-
-# Import the generic base
-from intentkit.skills.base import ToolException
-from intentkit.skills.venice_image.base import VeniceImageBaseTool
-from intentkit.skills.venice_image.image_generation.image_generation_input import (
-    VeniceImageGenerationInput,
-)
-from intentkit.utils.s3 import store_image_bytes
-
-logger = logging.getLogger(__name__)
-
-
-class VeniceImageGenerationBaseTool(VeniceImageBaseTool):
-    """
-    Base class for Venice AI *Image Generation* tools.
-    Inherits from VeniceAIBaseTool and handles specifics of the
-    /image/generate endpoint.
-    """
-
-    # --- Attributes specific to Image Generation ---
-    args_schema: Type[BaseModel] = VeniceImageGenerationInput
-
-    # --- Attributes Subclasses MUST Define ---
-    name: str = Field(description="The unique name of the image generation tool/model.")
-    description: str = Field(
-        description="A description of what the image generation tool/model does."
-    )
-    model_id: str = Field(
-        description="The specific model ID used in the Venice Image API call."
-    )
-
-    async def _arun(
-        self,
-        prompt: str,
-        seed: Optional[int] = None,
-        negative_prompt: Optional[str] = None,
-        width: Optional[int] = 1024,
-        height: Optional[int] = 1024,
-        format: Literal["png", "jpeg", "webp"] = "png",
-        cfg_scale: Optional[float] = 7.5,
-        style_preset: Optional[str] = "Photographic",
-        config: RunnableConfig = None,
-        **kwargs,
-    ) -> Dict[str, Any]:
-        try:
-            context = self.context_from_config(config)
-            skillConfig = self.getSkillConfig(context)
-            await self.apply_venice_rate_limit(context)
-
-            final_negative_prompt = negative_prompt or skillConfig.negative_prompt
-
-            payload = {
-                "model": self.model_id,
-                "prompt": prompt,
-                "width": width,
-                "height": height,
-                "seed": seed,
-                "format": format,
-                "steps": 30,
-                "safe_mode": skillConfig.safe_mode,
-                "hide_watermark": skillConfig.hide_watermark,
-                "embed_exif_metadata": skillConfig.embed_exif_metadata,
-                "cfg_scale": cfg_scale or 7.0,
-                "style_preset": style_preset,
-                "negative_prompt": final_negative_prompt,
-                "return_binary": False,
-            }
-
-            # Strip out None values
-            payload = {k: v for k, v in payload.items() if v is not None}
-
-            result, error = await self.post("/api/v1/image/generate", payload, context)
-
-            if error:
-                raise ToolException(f"Venice Image Generation API error: {error}")
-
-            base64_image_string = result.get("images", [None])[0]
-            if not base64_image_string:
-                raise ToolException("No image data found in Venice Image API response.")
-
-            try:
-                image_bytes = base64.b64decode(base64_image_string)
-            except Exception as decode_error:
-                raise ToolException("Invalid base64 image data.") from decode_error
-
-            response_format = (
-                result.get("request", {}).get("data", {}).get("format", format)
-            )
-            file_extension = response_format or format
-            content_type = f"image/{file_extension}"
-
-            image_hash = hashlib.sha256(image_bytes).hexdigest()
-            key = f"{self.category}/{self.model_id}/{image_hash}.{file_extension}"
-
-            stored_url = await store_image_bytes(
-                image_bytes, key, content_type=content_type
-            )
-
-            # Cleanup & enrich the response
-            result.pop("images", None)
-            result["image_url"] = stored_url
-            result["image_bytes_sha256"] = image_hash
-
-            return result
-        except ToolException as e:
-            raise e
-        except Exception as e:
-            raise ToolException(
-                "An unexpected error occurred during the image generation process."
-            ) from e
+import base64
+import hashlib
+import logging
+from typing import Any, Dict, Literal, Optional, Type
+
+from pydantic import BaseModel, Field
+
+# Import the generic base
+from intentkit.skills.base import ToolException
+from intentkit.skills.venice_image.base import VeniceImageBaseTool
+from intentkit.skills.venice_image.image_generation.image_generation_input import (
+    VeniceImageGenerationInput,
+)
+from intentkit.utils.s3 import store_image_bytes
+
+logger = logging.getLogger(__name__)
+
+
+class VeniceImageGenerationBaseTool(VeniceImageBaseTool):
+    """
+    Base class for Venice AI *Image Generation* tools.
+    Inherits from VeniceAIBaseTool and handles specifics of the
+    /image/generate endpoint.
+    """
+
+    # --- Attributes specific to Image Generation ---
+    args_schema: Type[BaseModel] = VeniceImageGenerationInput
+
+    # --- Attributes Subclasses MUST Define ---
+    name: str = Field(description="The unique name of the image generation tool/model.")
+    description: str = Field(
+        description="A description of what the image generation tool/model does."
+    )
+    model_id: str = Field(
+        description="The specific model ID used in the Venice Image API call."
+    )
+
+    async def _arun(
+        self,
+        prompt: str,
+        seed: Optional[int] = None,
+        negative_prompt: Optional[str] = None,
+        width: Optional[int] = 1024,
+        height: Optional[int] = 1024,
+        format: Literal["png", "jpeg", "webp"] = "png",
+        cfg_scale: Optional[float] = 7.5,
+        style_preset: Optional[str] = "Photographic",
+        **kwargs,
+    ) -> Dict[str, Any]:
+        try:
+            context = self.get_context()
+            skillConfig = self.getSkillConfig(context)
+            await self.apply_venice_rate_limit(context)
+
+            final_negative_prompt = negative_prompt or skillConfig.negative_prompt
+
+            payload = {
+                "model": self.model_id,
+                "prompt": prompt,
+                "width": width,
+                "height": height,
+                "seed": seed,
+                "format": format,
+                "steps": 30,
+                "safe_mode": skillConfig.safe_mode,
+                "hide_watermark": skillConfig.hide_watermark,
+                "embed_exif_metadata": skillConfig.embed_exif_metadata,
+                "cfg_scale": cfg_scale or 7.0,
+                "style_preset": style_preset,
+                "negative_prompt": final_negative_prompt,
+                "return_binary": False,
+            }
+
+            # Strip out None values
+            payload = {k: v for k, v in payload.items() if v is not None}
+
+            result, error = await self.post("/api/v1/image/generate", payload, context)
+
+            if error:
+                raise ToolException(f"Venice Image Generation API error: {error}")
+
+            base64_image_string = result.get("images", [None])[0]
+            if not base64_image_string:
+                raise ToolException("No image data found in Venice Image API response.")
+
+            try:
+                image_bytes = base64.b64decode(base64_image_string)
+            except Exception as decode_error:
+                raise ToolException("Invalid base64 image data.") from decode_error
+
+            response_format = (
+                result.get("request", {}).get("data", {}).get("format", format)
+            )
+            file_extension = response_format or format
+            content_type = f"image/{file_extension}"
+
+            image_hash = hashlib.sha256(image_bytes).hexdigest()
+            key = f"{self.category}/{self.model_id}/{image_hash}.{file_extension}"
+
+            stored_url = await store_image_bytes(
+                image_bytes, key, content_type=content_type
+            )
+
+            # Cleanup & enrich the response
+            result.pop("images", None)
+            result["image_url"] = stored_url
+            result["image_bytes_sha256"] = image_hash
+
+            return result
+        except ToolException as e:
+            raise e
+        except Exception as e:
+            raise ToolException(
+                "An unexpected error occurred during the image generation process."
+            ) from e

intentkit/skills/venice_image/image_upscale/image_upscale.py

@@ -1,90 +1,88 @@
-import logging
-from typing import Literal, Optional
-
-from langchain_core.runnables import RunnableConfig
-from pydantic import HttpUrl
-
-from intentkit.skills.base import ToolException
-from intentkit.skills.venice_image.image_upscale.image_upscale_base import (
-    VeniceImageUpscaleBaseTool,
-)
-from intentkit.skills.venice_image.utils import fetch_image_as_base64
-
-logger = logging.getLogger(__name__)
-
-
-class ImageUpscale(VeniceImageUpscaleBaseTool):
-    """
-    Upscales an existing image provided via URL by a factor of 2 or 4 using the Venice AI API.
-    Ideal for enhancing the resolution of previously generated or existing images.
-    """
-
-    # --- Tool Specific Configuration ---
-    name: str = "venice_image_upscale"
-    description: str = (
-        "Upscales an existing image from a URL using Venice AI.\n"
-        "Provide the public URL of the image to upscale.\n"
-        "Specify the desired scale factor: 2 (for 2x upscale) or 4 (for 4x upscale).\n"
-        "Returns the URL of the upscaled image."
-    )
-
-    # No model_id needed for the generic upscale endpoint currently
-    async def _arun(
-        self,
-        image_url: HttpUrl,
-        scale: Literal[2, 4],
-        replication: Optional[float] = 0.35,
-        config: RunnableConfig = None,
-        **kwargs,
-    ) -> dict:
-        """
-        Asynchronously upscales an image from the provided URL using the Venice AI API.
-
-        Args:
-            image_url (HttpUrl): The public URL of the image to upscale.
-            scale (Literal[2, 4]): The scale factor for upscaling (2x or 4x).
-            replication (Optional[float]): The replication factor for the upscale process, defaults to 0.35.
-            config (RunnableConfig, optional): Configuration for the runnable, if any.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            dict: The API response containing the URL of the upscaled image.
-
-        Raises:
-            ToolException: If the image cannot be fetched, validated, or upscaled, or if an API error occurs.
-        """
-
-        try:
-            context = self.context_from_config(config)
-
-            await self.apply_venice_rate_limit(context)
-
-            image_base64 = await fetch_image_as_base64(image_url)
-            if not image_base64:
-                error_msg = f"Failed to fetch or validate image from URL: {image_url}"
-                logger.error(error_msg)
-                raise ToolException(
-                    str({"success": False, "error": error_msg, "result": None})
-                )
-
-            payload = {
-                "image": image_base64,
-                "scale": scale,
-                "replication": replication,
-            }
-            result, error = await self.post("api/v1/image/upscale", payload, context)
-            if error:
-                raise ToolException(f"Venice Image Upscale API error: {error}")
-            return result
-        except ToolException as e:
-            raise e
-        except Exception as e:
-            logger.error(f"Error in {self.name}: {str(e)}")
-            raise ToolException(
-                str(
-                    {
-                        "success": False,
-                        "error": f"An unexpected error occurred: {str(e)}",
-                    }
-                )
-            )
+import logging
+from typing import Literal, Optional
+
+from pydantic import HttpUrl
+
+from intentkit.skills.base import ToolException
+from intentkit.skills.venice_image.image_upscale.image_upscale_base import (
+    VeniceImageUpscaleBaseTool,
+)
+from intentkit.skills.venice_image.utils import fetch_image_as_base64
+
+logger = logging.getLogger(__name__)
+
+
+class ImageUpscale(VeniceImageUpscaleBaseTool):
+    """
+    Upscales an existing image provided via URL by a factor of 2 or 4 using the Venice AI API.
+    Ideal for enhancing the resolution of previously generated or existing images.
+    """
+
+    # --- Tool Specific Configuration ---
+    name: str = "venice_image_upscale"
+    description: str = (
+        "Upscales an existing image from a URL using Venice AI.\n"
+        "Provide the public URL of the image to upscale.\n"
+        "Specify the desired scale factor: 2 (for 2x upscale) or 4 (for 4x upscale).\n"
+        "Returns the URL of the upscaled image."
+    )
+
+    # No model_id needed for the generic upscale endpoint currently
+    async def _arun(
+        self,
+        image_url: HttpUrl,
+        scale: Literal[2, 4],
+        replication: Optional[float] = 0.35,
+        **kwargs,
+    ) -> dict:
+        """
+        Asynchronously upscales an image from the provided URL using the Venice AI API.
+
+        Args:
+            image_url (HttpUrl): The public URL of the image to upscale.
+            scale (Literal[2, 4]): The scale factor for upscaling (2x or 4x).
+            replication (Optional[float]): The replication factor for the upscale process, defaults to 0.35.
+            config (RunnableConfig, optional): Configuration for the runnable, if any.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            dict: The API response containing the URL of the upscaled image.
+
+        Raises:
+            ToolException: If the image cannot be fetched, validated, or upscaled, or if an API error occurs.
+        """
+
+        try:
+            context = self.get_context()
+
+            await self.apply_venice_rate_limit(context)
+
+            image_base64 = await fetch_image_as_base64(image_url)
+            if not image_base64:
+                error_msg = f"Failed to fetch or validate image from URL: {image_url}"
+                logger.error(error_msg)
+                raise ToolException(
+                    str({"success": False, "error": error_msg, "result": None})
+                )
+
+            payload = {
+                "image": image_base64,
+                "scale": scale,
+                "replication": replication,
+            }
+            result, error = await self.post("api/v1/image/upscale", payload, context)
+            if error:
+                raise ToolException(f"Venice Image Upscale API error: {error}")
+            return result
+        except ToolException as e:
+            raise e
+        except Exception as e:
+            logger.error(f"Error in {self.name}: {str(e)}")
+            raise ToolException(
+                str(
+                    {
+                        "success": False,
+                        "error": f"An unexpected error occurred: {str(e)}",
+                    }
+                )
+            )