lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/components/jigsawstack/ai_scrape.py

@@ -0,0 +1,126 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import MessageTextInput, Output, SecretStrInput
+from lfx.schema.data import Data
+
+MAX_ELEMENT_PROMPTS = 5
+
+
+class JigsawStackAIScraperComponent(Component):
+    display_name = "AI Scraper"
+    description = "Scrape any website instantly and get consistent structured data \
+        in seconds without writing any css selector code"
+    documentation = "https://jigsawstack.com/docs/api-reference/ai/scrape"
+    icon = "JigsawStack"
+    name = "JigsawStackAIScraper"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="JigsawStack API Key",
+            info="Your JigsawStack API key for authentication",
+            required=True,
+        ),
+        MessageTextInput(
+            name="url",
+            display_name="URL",
+            info="URL of the page to scrape. Either url or html is required, but not both.",
+            required=False,
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="html",
+            display_name="HTML",
+            info="HTML content to scrape. Either url or html is required, but not both.",
+            required=False,
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="element_prompts",
+            display_name="Element Prompts",
+            info="Items on the page to be scraped (maximum 5). E.g. 'Plan price', 'Plan title'",
+            required=True,
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="root_element_selector",
+            display_name="Root Element Selector",
+            info="CSS selector to limit the scope of scraping to a specific element and its children",
+            required=False,
+            value="main",
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="AI Scraper Results", name="scrape_results", method="scrape"),
+    ]
+
+    def scrape(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
+            scrape_params: dict = {}
+            if self.url:
+                scrape_params["url"] = self.url
+            if self.html:
+                scrape_params["html"] = self.html
+
+            url_value = scrape_params.get("url", "")
+            html_value = scrape_params.get("html", "")
+            if (not url_value or not url_value.strip()) and (not html_value or not html_value.strip()):
+                url_or_html_error = "Either 'url' or 'html' must be provided for scraping"
+                raise ValueError(url_or_html_error)
+
+            # Process element_prompts with proper type handling
+            element_prompts_list: list[str] = []
+            if self.element_prompts:
+                element_prompts_value: str | list[str] = self.element_prompts
+
+                if isinstance(element_prompts_value, str):
+                    if "," not in element_prompts_value:
+                        element_prompts_list = [element_prompts_value]
+                    else:
+                        element_prompts_list = element_prompts_value.split(",")
+                elif isinstance(element_prompts_value, list):
+                    element_prompts_list = element_prompts_value
+                else:
+                    # Fallback for other types
+                    element_prompts_list = str(element_prompts_value).split(",")
+
+                if len(element_prompts_list) > MAX_ELEMENT_PROMPTS:
+                    max_elements_error = "Maximum of 5 element prompts allowed"
+                    raise ValueError(max_elements_error)
+                if len(element_prompts_list) == 0:
+                    invalid_elements_error = "Element prompts cannot be empty"
+                    raise ValueError(invalid_elements_error)
+
+                scrape_params["element_prompts"] = element_prompts_list
+
+            if self.root_element_selector:
+                scrape_params["root_element_selector"] = self.root_element_selector
+
+            # Call web scraping
+            response = client.web.ai_scrape(scrape_params)
+
+            if not response.get("success", False):
+                fail_error = "JigsawStack API request failed."
+                raise ValueError(fail_error)
+
+            result_data = response
+
+            self.status = "AI scrape process is now complete."
+
+            return Data(data=result_data)
+
+        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/ai_web_search.py

@@ -0,0 +1,136 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import BoolInput, DropdownInput, Output, QueryInput, SecretStrInput
+from lfx.schema.data import Data
+from lfx.schema.message import Message
+
+
+class JigsawStackAIWebSearchComponent(Component):
+    display_name = "AI Web Search"
+    description = "Effortlessly search the Web and get access to high-quality results powered with AI."
+    documentation = "https://jigsawstack.com/docs/api-reference/web/ai-search"
+    icon = "JigsawStack"
+    name = "JigsawStackAISearch"
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="JigsawStack API Key",
+            info="Your JigsawStack API key for authentication",
+            required=True,
+        ),
+        QueryInput(
+            name="query",
+            display_name="Query",
+            info="The search value. The maximum query character length is 400",
+            required=True,
+            tool_mode=True,
+        ),
+        BoolInput(
+            name="ai_overview",
+            display_name="AI Overview",
+            info="Include AI powered overview in the search results",
+            required=False,
+            value=True,
+        ),
+        DropdownInput(
+            name="safe_search",
+            display_name="Safe Search",
+            info="Enable safe search to filter out adult content",
+            required=False,
+            options=["moderate", "strict", "off"],
+            value="off",
+        ),
+        BoolInput(
+            name="spell_check",
+            display_name="Spell Check",
+            info="Spell check the search query",
+            required=False,
+            value=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="AI Search Results", name="search_results", method="search"),
+        Output(display_name="Content Text", name="content_text", method="get_content_text"),
+    ]
+
+    def search(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
+            search_params = {}
+            if self.query:
+                search_params["query"] = self.query
+            if self.ai_overview is not None:
+                search_params["ai_overview"] = self.ai_overview
+            if self.safe_search:
+                search_params["safe_search"] = self.safe_search
+            if self.spell_check is not None:
+                search_params["spell_check"] = self.spell_check
+
+            # Call web scraping
+            response = client.web.search(search_params)
+
+            api_error_msg = "JigsawStack API returned unsuccessful response"
+            if not response.get("success", False):
+                raise ValueError(api_error_msg)
+
+            # Create comprehensive data object
+            result_data = {
+                "query": self.query,
+                "ai_overview": response.get("ai_overview", ""),
+                "spell_fixed": response.get("spell_fixed", False),
+                "is_safe": response.get("is_safe", True),
+                "results": response.get("results", []),
+                "success": True,
+            }
+
+            self.status = f"Search complete for: {response.get('query', '')}"
+
+            return Data(data=result_data)
+
+        except JigsawStackError as e:
+            error_data = {"error": str(e), "success": False}
+            self.status = f"Error: {e!s}"
+            return Data(data=error_data)
+
+    def get_content_text(self) -> Message:
+        try:
+            from jigsawstack import JigsawStack, JigsawStackError
+        except ImportError:
+            return Message(text="Error: JigsawStack package not found.")
+
+        try:
+            # Initialize JigsawStack client
+            client = JigsawStack(api_key=self.api_key)
+            search_params = {}
+            if self.query:
+                search_params["query"] = self.query
+            if self.ai_overview is not None:
+                search_params["ai_overview"] = self.ai_overview
+            if self.safe_search:
+                search_params["safe_search"] = self.safe_search
+            if self.spell_check is not None:
+                search_params["spell_check"] = self.spell_check
+
+            # Call web scraping
+            response = client.web.search(search_params)
+
+            request_failed_msg = "Request Failed"
+            if not response.get("success", False):
+                raise JigsawStackError(request_failed_msg)
+
+            # Return the content as text
+            content = response.get("ai_overview", "")
+            return Message(text=content)
+
+        except JigsawStackError as e:
+            return Message(text=f"Error while using AI Search: {e!s}")

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)