lfx-nightly 0.2.0.dev25__py3-none-any.whl

lfx/components/jigsawstack/file_read.py

@@ -0,0 +1,115 @@
+import tempfile
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import Output, SecretStrInput, StrInput
+from lfx.schema.data import Data
+
+
+class JigsawStackFileReadComponent(Component):
+    display_name = "File Read"
+    description = "Read any previously uploaded file seamlessly from \
+        JigsawStack File Storage and use it in your AI applications."
+    documentation = "https://jigsawstack.com/docs/api-reference/store/file/get"
+    icon = "JigsawStack"
+    name = "JigsawStackFileRead"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="JigsawStack API Key",
+            info="Your JigsawStack API key for authentication",
+            required=True,
+        ),
+        StrInput(
+            name="key",
+            display_name="Key",
+            info="The key used to retrieve the file from JigsawStack File Storage.",
+            required=True,
+            tool_mode=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="File Path", name="file_path", method="read_and_save_file"),
+    ]
+
+    def read_and_save_file(self) -> Data:
+        """Read file from JigsawStack and save to temp file, return file path."""
+        try:
+            from jigsawstack import JigsawStack, JigsawStackError
+        except ImportError as e:
+            jigsawstack_import_error = (
+                "JigsawStack package not found. Please install it using: pip install jigsawstack>=0.2.7"
+            )
+            raise ImportError(jigsawstack_import_error) from e
+
+        try:
+            client = JigsawStack(api_key=self.api_key)
+            if not self.key or self.key.strip() == "":
+                invalid_key_error = "Key is required to read a file from JigsawStack File Storage."
+                raise ValueError(invalid_key_error)
+
+            # Download file content
+            response = client.store.get(self.key)
+
+            # Determine file extension
+            file_extension = self._detect_file_extension(response)
+
+            # Create temporary file
+            with tempfile.NamedTemporaryFile(
+                delete=False, suffix=file_extension, prefix=f"jigsawstack_{self.key}_"
+            ) as temp_file:
+                if isinstance(response, bytes):
+                    temp_file.write(response)
+                else:
+                    # Handle string content
+                    temp_file.write(response.encode("utf-8"))
+
+                temp_path = temp_file.name
+
+            return Data(
+                data={
+                    "file_path": temp_path,
+                    "key": self.key,
+                    "file_extension": file_extension,
+                    "size": len(response) if isinstance(response, bytes) else len(str(response)),
+                    "success": True,
+                }
+            )
+
+        except JigsawStackError as e:
+            error_data = {"error": str(e), "success": False}
+            self.status = f"Error: {e!s}"
+            return Data(data=error_data)
+
+    def _detect_file_extension(self, content) -> str:
+        """Detect file extension based on content headers."""
+        if isinstance(content, bytes):
+            # Check magic numbers for common file types
+            if content.startswith(b"\xff\xd8\xff"):
+                return ".jpg"
+            if content.startswith(b"\x89PNG\r\n\x1a\n"):
+                return ".png"
+            if content.startswith((b"GIF87a", b"GIF89a")):
+                return ".gif"
+            if content.startswith(b"%PDF"):
+                return ".pdf"
+            if content.startswith(b"PK\x03\x04"):  # ZIP/DOCX/XLSX
+                return ".zip"
+            if content.startswith(b"\x00\x00\x01\x00"):  # ICO
+                return ".ico"
+            if content.startswith(b"RIFF") and b"WEBP" in content[:12]:
+                return ".webp"
+            if content.startswith((b"\xff\xfb", b"\xff\xf3", b"\xff\xf2")):
+                return ".mp3"
+            if content.startswith((b"ftypmp4", b"\x00\x00\x00\x20ftypmp4")):
+                return ".mp4"
+            # Try to decode as text
+            try:
+                content.decode("utf-8")
+                return ".txt"  # noqa: TRY300
+            except UnicodeDecodeError:
+                return ".bin"  # Binary file
+        else:
+            # String content
+            return ".txt"

lfx/components/jigsawstack/file_upload.py

@@ -0,0 +1,94 @@
+from pathlib import Path
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import BoolInput, FileInput, Output, SecretStrInput, StrInput
+from lfx.schema.data import Data
+
+
+class JigsawStackFileUploadComponent(Component):
+    display_name = "File Upload"
+    description = "Store any file seamlessly on JigsawStack File Storage and use it in your AI applications. \
+        Supports various file types including images, documents, and more."
+    documentation = "https://jigsawstack.com/docs/api-reference/store/file/add"
+    icon = "JigsawStack"
+    name = "JigsawStackFileUpload"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="JigsawStack API Key",
+            info="Your JigsawStack API key for authentication",
+            required=True,
+        ),
+        FileInput(
+            name="file",
+            display_name="File",
+            info="Upload file to be stored on JigsawStack File Storage.",
+            required=True,
+            file_types=["pdf", "png", "jpg", "jpeg", "mp4", "mp3", "txt", "docx", "xlsx"],
+        ),
+        StrInput(
+            name="key",
+            display_name="Key",
+            info="The key used to store the file on JigsawStack File Storage. \
+                If not provided, a unique key will be generated.",
+            required=False,
+            tool_mode=True,
+        ),
+        BoolInput(
+            name="overwrite",
+            display_name="Overwrite Existing File",
+            info="If true, will overwrite the existing file with the same key. \
+                If false, will return an error if the file already exists.",
+            required=False,
+            value=True,
+        ),
+        BoolInput(
+            name="temp_public_url",
+            display_name="Return Temporary Public URL",
+            info="If true, will return a temporary public URL which lasts for a limited time. \
+                If false, will return the file store key which can only be accessed by the owner.",
+            required=False,
+            value=False,
+            tool_mode=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="File Store Result", name="file_upload_result", method="upload_file"),
+    ]
+
+    def upload_file(self) -> Data:
+        try:
+            from jigsawstack import JigsawStack, JigsawStackError
+        except ImportError as e:
+            jigsawstack_import_error = (
+                "JigsawStack package not found. Please install it using: pip install jigsawstack>=0.2.7"
+            )
+            raise ImportError(jigsawstack_import_error) from e
+
+        try:
+            client = JigsawStack(api_key=self.api_key)
+
+            file_path = Path(self.file)
+            with Path.open(file_path, "rb") as f:
+                file_content = f.read()
+            params = {}
+
+            if self.key:
+                # if key is provided, use it as the file store key
+                params["key"] = self.key
+            if self.overwrite is not None:
+                # if overwrite is provided, use it to determine if the file should be overwritten
+                params["overwrite"] = self.overwrite
+            if self.temp_public_url is not None:
+                # if temp_public_url is provided, use it to determine if a temporary public URL should
+                params["temp_public_url"] = self.temp_public_url
+
+            response = client.store.upload(file_content, params)
+            return Data(data=response)
+
+        except JigsawStackError as e:
+            error_data = {"error": str(e), "success": False}
+            self.status = f"Error: {e!s}"
+            return Data(data=error_data)

lfx/components/jigsawstack/image_generation.py

@@ -0,0 +1,205 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import DropdownInput, IntInput, MessageTextInput, Output, SecretStrInput
+from lfx.schema.data import Data
+
+
+class JigsawStackImageGenerationComponent(Component):
+    display_name = "Image Generation"
+    description = "Generate an image based on the given text by employing AI models like Flux, \
+        Stable Diffusion, and other top models."
+    documentation = "https://jigsawstack.com/docs/api-reference/ai/image-generation"
+    icon = "JigsawStack"
+    name = "JigsawStackImageGeneration"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="JigsawStack API Key",
+            info="Your JigsawStack API key for authentication",
+            required=True,
+        ),
+        MessageTextInput(
+            name="prompt",
+            display_name="Prompt",
+            info="The text prompt to generate the image from. Must be between 1-5000 characters.",
+            required=True,
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="aspect_ratio",
+            display_name="Aspect Ratio",
+            info="The aspect ratio of the generated image. Must be one of the following:\
+                '1:1', '16:9', '21:9', '3:2', '2:3', '4:5', '5:4', '3:4', '4:3', '9:16', '9:21' \
+                Default is 1:1.",
+            required=False,
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="url",
+            display_name="URL",
+            info="A valid URL where the generated image will be sent.",
+            required=False,
+        ),
+        MessageTextInput(
+            name="file_store_key",
+            display_name="File Store Key",
+            info="The key used to store the image on Jigsawstack File Storage. Not required if url is specified.",
+            required=False,
+            tool_mode=True,
+        ),
+        IntInput(
+            name="width",
+            display_name="Width",
+            info="The width of the image. Must be between 256-1920 pixels.",
+            required=False,
+        ),
+        IntInput(
+            name="height",
+            display_name="Height",
+            info="The height of the image. Must be between 256-1920 pixels.",
+            required=False,
+        ),
+        IntInput(
+            name="steps",
+            display_name="Steps",
+            info="The number of denoising steps. Must be between 1-90. \
+                Higher values produce better quality images but take more time to generate.",
+            required=False,
+        ),
+        DropdownInput(
+            name="output_format",
+            display_name="Output Format",
+            info="The output format of the generated image. Must be one of the following values:\
+                png or svg",
+            required=False,
+            options=["png", "svg"],
+            value="png",
+        ),
+        MessageTextInput(
+            name="negative_prompt",
+            display_name="Negative Prompt",
+            info="The text prompt to avoid in the generated image. \
+                Must be between 1-5000 characters.",
+            required=False,
+            tool_mode=True,
+            advanced=True,
+        ),
+        IntInput(
+            name="seed",
+            display_name="Seed",
+            info="Makes generation deterministic.\
+                Using the same seed and set of parameters will produce identical image each time.",
+            required=False,
+            tool_mode=True,
+            advanced=True,
+        ),
+        IntInput(
+            name="guidance",
+            display_name="Guidance Scale",
+            info="Higher guidance forces the model to better follow the prompt, \
+                but may result in lower quality output. Must be between 1-28.",
+            required=False,
+            tool_mode=True,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Image Generation Results", name="image_generation_results", method="generate_image"),
+    ]
+
+    def generate_image(self) -> Data:
+        try:
+            from jigsawstack import JigsawStack, JigsawStackError
+        except ImportError as e:
+            jigsawstack_import_error = (
+                "JigsawStack package not found. Please install it using: pip install jigsawstack>=0.2.7"
+            )
+            raise ImportError(jigsawstack_import_error) from e
+
+        try:
+            min_character_length = 1
+            max_character_length = 5000
+            min_width = 256
+            max_width = 1920
+            min_height = 256
+            max_height = 1920
+            min_steps = 1
+            max_steps = 90
+            client = JigsawStack(api_key=self.api_key)
+
+            if not self.prompt or len(self.prompt) < min_character_length or len(self.prompt) > max_character_length:
+                invalid_prompt_error = f"Prompts must be between \
+                    {min_character_length}-{max_character_length} characters."
+                raise ValueError(invalid_prompt_error)
+
+            if self.aspect_ratio and self.aspect_ratio not in [
+                "1:1",
+                "16:9",
+                "21:9",
+                "3:2",
+                "2:3",
+                "4:5",
+                "5:4",
+                "3:4",
+                "4:3",
+                "9:16",
+                "9:21",
+            ]:
+                invalid_aspect_ratio_error = (
+                    "Aspect ratio must be one of the following: '1:1', '16:9', '21:9', '3:2', '2:3', "
+                    "'4:5', '5:4', '3:4', '4:3', '9:16', '9:21'."
+                )
+                raise ValueError(invalid_aspect_ratio_error)
+            if self.width and (self.width < min_width or self.width > max_width):
+                invalid_width_error = f"Width must be between {min_width}-{max_width} pixels."
+                raise ValueError(invalid_width_error)
+            if self.height and (self.height < min_height or self.height > max_height):
+                invalid_height_error = f"Height must be between {min_height}-{max_height} pixels."
+                raise ValueError(invalid_height_error)
+            if self.steps and (self.steps < min_steps or self.steps > max_steps):
+                invalid_steps_error = f"Steps must be between {min_steps}-{max_steps}."
+                raise ValueError(invalid_steps_error)
+
+            params = {}
+            if self.prompt:
+                params["prompt"] = self.prompt.strip()
+            if self.aspect_ratio:
+                params["aspect_ratio"] = self.aspect_ratio.strip()
+            if self.url:
+                params["url"] = self.url.strip()
+            if self.file_store_key:
+                params["file_store_key"] = self.file_store_key.strip()
+            if self.width:
+                params["width"] = self.width
+            if self.height:
+                params["height"] = self.height
+            params["return_type"] = "url"
+            if self.output_format:
+                params["output_format"] = self.output_format.strip()
+            if self.steps:
+                params["steps"] = self.steps
+
+            # Initialize advance_config if any advanced parameters are provided
+            if self.negative_prompt or self.seed or self.guidance:
+                params["advance_config"] = {}
+            if self.negative_prompt:
+                params["advance_config"]["negative_prompt"] = self.negative_prompt
+            if self.seed:
+                params["advance_config"]["seed"] = self.seed
+            if self.guidance:
+                params["advance_config"]["guidance"] = self.guidance
+
+            # Call image generation
+            response = client.image_generation(params)
+
+            if response.get("url", None) is None or response.get("url", None).strip() == "":
+                failed_response_error = "JigsawStack API returned unsuccessful response"
+                raise ValueError(failed_response_error)
+
+            return Data(data=response)
+
+        except JigsawStackError as e:
+            error_data = {"error": str(e), "success": False}
+            self.status = f"Error: {e!s}"
+            return Data(data=error_data)

lfx/components/jigsawstack/nsfw.py

@@ -0,0 +1,60 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import Output, SecretStrInput, StrInput
+from lfx.schema.data import Data
+
+
+class JigsawStackNSFWComponent(Component):
+    display_name = "NSFW Detection"
+    description = "Detect if image/video contains NSFW content"
+    documentation = "https://jigsawstack.com/docs/api-reference/ai/nsfw"
+    icon = "JigsawStack"
+    name = "JigsawStackNSFW"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="JigsawStack API Key",
+            info="Your JigsawStack API key for authentication",
+            required=True,
+        ),
+        StrInput(
+            name="url",
+            display_name="URL",
+            info="URL of the image or video to analyze",
+            required=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="NSFW Analysis", name="nsfw_result", method="detect_nsfw"),
+    ]
+
+    def detect_nsfw(self) -> Data:
+        try:
+            from jigsawstack import JigsawStack, JigsawStackError
+        except ImportError as e:
+            jigsawstack_import_error = (
+                "JigsawStack package not found. Please install it using: pip install jigsawstack>=0.2.7"
+            )
+            raise ImportError(jigsawstack_import_error) from e
+
+        try:
+            client = JigsawStack(api_key=self.api_key)
+
+            # Build request parameters
+            params = {"url": self.url}
+
+            response = client.validate.nsfw(params)
+
+            api_error_msg = "JigsawStack API returned unsuccessful response"
+            if not response.get("success", False):
+                raise ValueError(api_error_msg)
+
+            return Data(data=response)
+
+        except ValueError:
+            raise
+        except JigsawStackError as e:
+            error_data = {"error": str(e), "success": False}
+            self.status = f"Error: {e!s}"
+            return Data(data=error_data)

lfx/components/jigsawstack/object_detection.py

@@ -0,0 +1,124 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import BoolInput, DropdownInput, MessageTextInput, Output, SecretStrInput
+from lfx.schema.data import Data
+
+
+class JigsawStackObjectDetectionComponent(Component):
+    display_name = "Object Detection"
+    description = "Perform object detection on images using JigsawStack's Object Detection Model, \
+        capable of image grounding, segmentation and computer use."
+    documentation = "https://jigsawstack.com/docs/api-reference/ai/object-detection"
+    icon = "JigsawStack"
+    name = "JigsawStackObjectDetection"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="JigsawStack API Key",
+            info="Your JigsawStack API key for authentication",
+            required=True,
+        ),
+        MessageTextInput(
+            name="prompts",
+            display_name="Prompts",
+            info="The prompts to ground the object detection model. \
+                You can pass a list of comma-separated prompts to extract different information from the image.",
+            required=False,
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="url",
+            display_name="URL",
+            info="The image URL. Not required if file_store_key is specified.",
+            required=False,
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="file_store_key",
+            display_name="File Store Key",
+            info="The key used to store the image on Jigsawstack File Storage. Not required if url is specified.",
+            required=False,
+            tool_mode=True,
+        ),
+        BoolInput(
+            name="annotated_image",
+            display_name="Return Annotated Image",
+            info="If true, will return an url for annotated image with detected objects.",
+            required=False,
+            value=True,
+        ),
+        DropdownInput(
+            name="features",
+            display_name="Features",
+            info="Select the features to enable for object detection",
+            required=False,
+            options=["object_detection", "gui"],
+            value=["object_detection", "gui"],
+        ),
+        DropdownInput(
+            name="return_type",
+            display_name="Return Type",
+            info="Select the return type for the object detection results such as masks or annotations.",
+            required=False,
+            options=["url", "base64"],
+            value="url",
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Object Detection results", name="object_detection_results", method="detect_objects"),
+    ]
+
+    def detect_objects(self) -> Data:
+        try:
+            from jigsawstack import JigsawStack, JigsawStackError
+        except ImportError as e:
+            jigsawstack_import_error = (
+                "JigsawStack package not found. Please install it using: pip install jigsawstack>=0.2.7"
+            )
+            raise ImportError(jigsawstack_import_error) from e
+
+        try:
+            client = JigsawStack(api_key=self.api_key)
+
+            # build request object
+            params = {}
+            if self.prompts:
+                if isinstance(self.prompts, list):
+                    params["prompt"] = self.prompts
+                elif isinstance(self.prompts, str):
+                    if "," in self.prompts:
+                        # Split by comma and strip whitespace
+                        params["prompt"] = [p.strip() for p in self.prompts.split(",")]
+                    else:
+                        params["prompt"] = [self.prompts.strip()]
+                else:
+                    invalid_prompt_error = "Prompt must be a list of strings or a single string"
+                    raise ValueError(invalid_prompt_error)
+            if self.url:
+                params["url"] = self.url
+            if self.file_store_key:
+                params["file_store_key"] = self.file_store_key
+
+            # if both url and file_store_key are not provided, raise an error
+            if not self.url and not self.file_store_key:
+                missing_url_error = "Either URL or File Store Key must be provided to perform object detection"
+                raise ValueError(missing_url_error)
+
+            params["annotated_image"] = self.annotated_image
+            if self.features:
+                params["features"] = self.features
+
+            # Call web scraping
+            response = client.vision.object_detection(params)
+
+            if not response.get("success", False):
+                failed_response_error = "JigsawStack API returned unsuccessful response"
+                raise ValueError(failed_response_error)
+
+            return Data(data=response)
+
+        except JigsawStackError as e:
+            error_data = {"error": str(e), "success": False}
+            self.status = f"Error: {e!s}"
+            return Data(data=error_data)