lfx-serpingapi 0.1.0__py3-none-any.whl

lfx_serpingapi/__init__.py

@@ -0,0 +1,15 @@
+"""lfx-serpingapi: Serping API Search bundle.
+
+This package is the distribution unit ``lfx-serpingapi``.  At runtime
+Langflow's loader discovers ``extension.json`` shipped alongside this
+``__init__.py`` and registers ``SerpingApiSearchComponent`` under the
+namespaced ID ``ext:serpingapi:SerpingApiSearchComponent@official``.
+
+Serping API (https://serpingapi.com) is a Google SERP API; the component
+calls its search endpoint directly with ``httpx`` and needs only a
+user-supplied API key, so the bundle carries no vendor SDK dependency.
+"""
+
+from lfx_serpingapi.components.serpingapi.serpingapi_search import SerpingApiSearchComponent
+
+__all__ = ["SerpingApiSearchComponent"]

lfx_serpingapi/components/serpingapi/__init__.py

@@ -0,0 +1,3 @@
+from .serpingapi_search import SerpingApiSearchComponent
+
+__all__ = ["SerpingApiSearchComponent"]

lfx_serpingapi/components/serpingapi/serpingapi_search.py

@@ -0,0 +1,176 @@
+import httpx
+from lfx.custom.custom_component.component import Component
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.inputs.inputs import IntInput, MessageTextInput, SecretStrInput
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+from lfx.template.field.base import Output
+
+SEARCH_ENDPOINT = "https://api.serpingapi.com/v1/search"
+DEFAULT_RESULTS = 10
+MIN_RESULTS = 1
+MAX_RESULTS = 100
+FIRST_PAGE = 1
+
+
+def _http_error_message(error: httpx.HTTPStatusError) -> str:
+    """Describe a non-2xx Serping API response, keeping the API's own error message.
+
+    Serping API errors carry ``{"error": {"code": ..., "message": ...}}``.
+    """
+    response = error.response
+    detail = None
+    try:
+        payload = response.json()
+        body_error = payload.get("error") if isinstance(payload, dict) else None
+        if isinstance(body_error, dict):
+            detail = body_error.get("message") or body_error.get("code")
+        elif isinstance(body_error, str):
+            detail = body_error
+    except ValueError:
+        detail = None
+    reason = detail or response.reason_phrase or "request failed"
+    return f"Serping API error {response.status_code}: {reason}"
+
+
+class SerpingApiSearchComponent(Component):
+    """Component for performing web searches using the Serping API."""
+
+    display_name = "Serping API Search"
+    description = "Search Google organic results with the Serping API."
+    documentation = "https://serpingapi.com/docs"
+    icon = "search"
+
+    inputs = [
+        MessageTextInput(
+            name="input_value",
+            display_name="Search Query",
+            required=True,
+            info="The search query to execute with the Serping API.",
+            tool_mode=True,
+        ),
+        SecretStrInput(
+            name="serpingapi_api_key",
+            display_name="Serping API Key",
+            required=True,
+            info="Your Serping API key. Get one at https://serpingapi.com.",
+            password=True,
+        ),
+        MessageTextInput(
+            name="gl",
+            display_name="Country",
+            required=False,
+            advanced=True,
+            info="Country code for the results, for example 'us', 'de' or 'jp'.",
+        ),
+        MessageTextInput(
+            name="hl",
+            display_name="Language",
+            required=False,
+            advanced=True,
+            info="Interface language, for example 'en' or 'es'.",
+        ),
+        MessageTextInput(
+            name="location",
+            display_name="Location",
+            required=False,
+            advanced=True,
+            info="Locality for the search, for example 'Seattle, Washington, United States'.",
+        ),
+        IntInput(
+            name="max_results",
+            display_name="Max Results",
+            value=DEFAULT_RESULTS,
+            required=False,
+            advanced=True,
+            range_spec=RangeSpec(min=MIN_RESULTS, max=MAX_RESULTS, step=1, step_type="int"),
+            info="Maximum number of organic results to return (1-100).",
+        ),
+        IntInput(
+            name="page",
+            display_name="Page",
+            value=FIRST_PAGE,
+            required=False,
+            advanced=True,
+            range_spec=RangeSpec(min=FIRST_PAGE, max=100, step=1, step_type="int"),
+            info="Result page to fetch, starting at 1.",
+        ),
+    ]
+
+    outputs = [
+        # The method name is also the tool name in tool mode.  Keep it specific:
+        # DuckDuckGo, Tavily, Wikipedia and other search components already expose
+        # ``fetch_content_dataframe``, and an Agent cannot hold two tools with the
+        # same name.
+        Output(display_name="Table", name="dataframe", method="serpingapi_search"),
+    ]
+
+    def _request_body(self) -> dict:
+        """Build the JSON body for the Serping API search endpoint."""
+        requested = DEFAULT_RESULTS if self.max_results is None else int(self.max_results)
+        num = max(MIN_RESULTS, min(requested, MAX_RESULTS))
+        body: dict = {"q": self.input_value or "", "num": num}
+        for field in ("gl", "hl", "location"):
+            value = getattr(self, field, None)
+            if isinstance(value, str) and value.strip():
+                body[field] = value.strip()
+        page = FIRST_PAGE if self.page is None else int(self.page)
+        if page > FIRST_PAGE:
+            body["page"] = page
+        return body
+
+    def _search(self) -> dict:
+        """Call the Serping API search endpoint and return the decoded JSON payload."""
+        if not self.serpingapi_api_key:
+            msg = "Serping API key is required. Set the Serping API Key input."
+            raise ValueError(msg)
+
+        headers = {
+            "X-API-Key": self.serpingapi_api_key,
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            # Identify the integration to the API; keeps traffic attributable.
+            "User-Agent": "langflow-serpingapi-bundle",
+        }
+        response = httpx.post(SEARCH_ENDPOINT, json=self._request_body(), headers=headers, timeout=30)
+        response.raise_for_status()
+        return response.json()
+
+    def _error_result(self, message: str) -> list[Data]:
+        error_data = [Data(text=message, data={"error": message})]
+        self.status = error_data
+        return error_data
+
+    @staticmethod
+    def _result_to_data(result: dict) -> Data:
+        snippet = result.get("snippet", "")
+        return Data(
+            text=snippet,
+            data={
+                "title": result.get("title", ""),
+                "link": result.get("link", ""),
+                "snippet": snippet,
+                "position": result.get("position"),
+            },
+        )
+
+    def fetch_content(self) -> list[Data]:
+        """Execute the search and return the organic results as Data objects."""
+        try:
+            payload = self._search()
+        except httpx.HTTPStatusError as e:
+            return self._error_result(_http_error_message(e))
+        except (httpx.HTTPError, ValueError) as e:
+            return self._error_result(str(e))
+
+        if not isinstance(payload, dict):
+            return self._error_result("Serping API returned an unexpected response (expected a JSON object).")
+
+        results = payload.get("organic") or []
+        data_results = [self._result_to_data(result) for result in results if isinstance(result, dict)]
+        self.status = data_results
+        return data_results
+
+    def serpingapi_search(self) -> DataFrame:
+        """Run the search and return the organic results as a DataFrame."""
+        return DataFrame(self.fetch_content())

lfx_serpingapi/extension.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://schemas.langflow.org/extension/v1.json",
+  "id": "lfx-serpingapi",
+  "version": "0.1.0",
+  "name": "Serping API",
+  "description": "Serping API Google SERP web-search component as a standalone Langflow Extension Bundle.",
+  "lfx": {
+    "compat": ["1"]
+  },
+  "bundles": [
+    {
+      "name": "serpingapi",
+      "path": "components/serpingapi"
+    }
+  ]
+}

lfx_serpingapi-0.1.0.dist-info/METADATA

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: lfx-serpingapi
+Version: 0.1.0
+Summary: Serping API Google SERP web-search component as a standalone Langflow Extension Bundle.
+Project-URL: Homepage, https://github.com/langflow-ai/langflow
+Project-URL: Documentation, https://docs.langflow.org/extensions
+Project-URL: Repository, https://github.com/langflow-ai/langflow
+Author-email: Langflow <contact@langflow.org>
+License: MIT
+Keywords: bundle,extension,langflow,lfx,search,serp,serpingapi
+Requires-Python: <3.15,>=3.10
+Requires-Dist: httpx<1.0.0,>=0.24.0
+Requires-Dist: lfx<2.0.0,>=1.13.0.dev0
+Description-Content-Type: text/markdown
+
+# lfx-serpingapi
+
+Serping API Google SERP web-search component as a standalone Langflow Extension Bundle.
+
+The bundle ships a single component, `SerpingApiSearchComponent`, which runs
+a web search through the [Serping API](https://serpingapi.com) and returns
+the organic Google results as a table. It calls the Serping API search
+endpoint directly with `httpx` and needs only a user-supplied API key, so it
+carries no vendor SDK dependency. See the
+[Serping API docs](https://serpingapi.com/docs) for the API details.
+
+## Install
+
+```bash
+pip install lfx-serpingapi
+```
+
+The bundle is registered automatically via the `langflow.extensions`
+entry-point. After install, restart your Langflow server; the
+`SerpingApiSearchComponent` will appear in the palette's **Bundles** section
+under **Serping API**.
+
+## Configure
+
+Set the **Serping API Key** input to your own key from
+[serpingapi.com](https://serpingapi.com). The component is optional and does
+nothing until a key is supplied, so it changes nothing for anyone who does
+not use it. Country (`gl`), language (`hl`), location, max results (1-100)
+and page are optional advanced inputs.
+
+In tool mode, the component exposes a single tool named `serpingapi_search`.
+
+## Develop
+
+```bash
+cd src/bundles/serpingapi
+pip install -e .
+lfx extension validate src/lfx_serpingapi
+```
+
+## Manifest
+
+The extension manifest is shipped at `src/lfx_serpingapi/extension.json` and
+points at the bundle at `components/serpingapi`. The component registers under
+the canonical namespaced ID `ext:serpingapi:SerpingApiSearchComponent@official`.

lfx_serpingapi-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+lfx_serpingapi/__init__.py,sha256=V21xnObdW36K33lDOBtxd76w8_VSu21Qh3Q5VVb-FJ8,677
+lfx_serpingapi/extension.json,sha256=xVpiUGUFfItir6z60HPj2InWGuGaY_EebszTTziu9yY,381
+lfx_serpingapi/components/serpingapi/__init__.py,sha256=W0iZQhQxVWg2P_OOGpMw-zdSkFMI6hW0paFhxWJJ4KA,98
+lfx_serpingapi/components/serpingapi/serpingapi_search.py,sha256=QXobb-9CkGsf-mAGPdl0COLgxjEJxpO6uHk9pXpcOK4,6671
+lfx_serpingapi-0.1.0.dist-info/METADATA,sha256=xGXCdAWMZkYmgZy_BoRGENSN99U60izfjN4Vc_tmuuU,2193
+lfx_serpingapi-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+lfx_serpingapi-0.1.0.dist-info/entry_points.txt,sha256=GhaFOfWCRihPgSutE5n5E7kDmzlxga20O0_o86vMlLA,54
+lfx_serpingapi-0.1.0.dist-info/RECORD,,

lfx_serpingapi-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

lfx_serpingapi-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[langflow.extensions]
+lfx-serpingapi = lfx_serpingapi