lfx-oracle 0.1.0__py3-none-any.whl

lfx_oracle/__init__.py

@@ -0,0 +1,21 @@
+"""lfx-oracle: Oracle Database bundle.
+
+Distribution unit ``lfx-oracle``.  At runtime Langflow's loader
+discovers ``extension.json`` shipped alongside this ``__init__.py`` and
+registers the bundle's components under the namespaced IDs
+``ext:oracle:<Class>@official``.
+"""
+
+from lfx_oracle.components.oracle.oracledb_embeddings import OracleEmbeddingsComponent
+from lfx_oracle.components.oracle.oracledb_loaders import (
+    OracleAutonomousDatabaseLoaderComponent,
+    OracleDocLoaderComponent,
+)
+from lfx_oracle.components.oracle.oraclevs import OracleVectorStoreComponent
+
+__all__ = [
+    "OracleAutonomousDatabaseLoaderComponent",
+    "OracleDocLoaderComponent",
+    "OracleEmbeddingsComponent",
+    "OracleVectorStoreComponent",
+]

lfx_oracle/components/oracle/__init__.py

@@ -0,0 +1,18 @@
+"""Component re-exports for the ``oracle`` bundle.
+
+Saved-flow migration entries that target the legacy in-tree
+``lfx.components.oracledb.<Class>`` import paths resolve through this
+package, so the moved Component class(es) must be importable from here
+by name.
+"""
+
+from .oracledb_embeddings import OracleEmbeddingsComponent
+from .oracledb_loaders import OracleAutonomousDatabaseLoaderComponent, OracleDocLoaderComponent
+from .oraclevs import OracleVectorStoreComponent
+
+__all__ = [
+    "OracleAutonomousDatabaseLoaderComponent",
+    "OracleDocLoaderComponent",
+    "OracleEmbeddingsComponent",
+    "OracleVectorStoreComponent",
+]

lfx_oracle/components/oracle/connection.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+_SENSITIVE_CONNECTION_PARAM_KEYS = {
+    "access_token",
+    "connection_string",
+    "credential",
+    "credentials",
+    "dsn",
+    "newpassword",
+    "passwd",
+    "password",
+    "private_key",
+    "proxy_user",
+    "pwd",
+    "secret",
+    "tns",
+    "token",
+    "user",
+    "username",
+    "wallet_password",
+}
+
+
+def _is_sensitive_connection_param_key(key: str) -> bool:
+    normalized_key = re.sub(r"[^0-9a-zA-Z]+", "_", key.strip().lower()).strip("_")
+    compact_key = normalized_key.replace("_", "")
+    return any(
+        normalized_key == sensitive_key or compact_key == sensitive_key.replace("_", "")
+        for sensitive_key in _SENSITIVE_CONNECTION_PARAM_KEYS
+    )
+
+
+def split_credentialized_dsn(dsn: str) -> tuple[str | None, str | None, str]:
+    if "@" not in dsn:
+        return None, None, dsn
+
+    credentials, dsn_without_credentials = dsn.rsplit("@", 1)
+    if "/" not in credentials:
+        return None, None, dsn
+
+    user, password = credentials.split("/", 1)
+    return user or None, password or None, dsn_without_credentials
+
+
+def build_connection_params(
+    connection_params: dict[str, Any] | None = None,
+    *,
+    user: str | None = None,
+    password: str | None = None,
+    dsn: str | None = None,
+    wallet_password: str | None = None,
+) -> dict[str, Any]:
+    raw_params = {key: value for key, value in (connection_params or {}).items() if value not in (None, "")}
+    sensitive_keys = sorted(key for key in raw_params if _is_sensitive_connection_param_key(key))
+    if sensitive_keys:
+        keys = ", ".join(sensitive_keys)
+        msg = (
+            f"connection_params contains sensitive keys: {keys}. "
+            "Use the dedicated secret fields for user, password, dsn, wallet_password, and proxy."
+        )
+        raise ValueError(msg)
+
+    if isinstance(dsn, str) and (not user or not password):
+        parsed_user, parsed_password, parsed_dsn = split_credentialized_dsn(dsn)
+        user = user or parsed_user
+        password = password or parsed_password
+        dsn = parsed_dsn
+
+    params = dict(raw_params)
+
+    if user:
+        params["user"] = user
+    if password:
+        params["password"] = password
+    if dsn:
+        params["dsn"] = dsn
+    if wallet_password:
+        params["wallet_password"] = wallet_password
+
+    return params

lfx_oracle/components/oracle/oracledb_embeddings.py

@@ -0,0 +1,70 @@
+from contextlib import suppress
+from typing import Any
+
+import oracledb
+from langchain_oracledb import OracleEmbeddings
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import Embeddings
+from lfx.io import DictInput, Output, SecretStrInput
+
+from .connection import build_connection_params
+
+
+class OracleEmbeddingsComponent(LCModelComponent):
+    display_name = "Oracle Embeddings"
+    description = "Generate embeddings using Oracle AI Vector Search."
+    icon = "Oracle"
+    name = "OracleEmbeddings"
+
+    inputs = [
+        SecretStrInput(name="user", display_name="User", required=False),
+        SecretStrInput(name="password", display_name="Password", required=False),
+        SecretStrInput(name="dsn", display_name="DSN", required=True),
+        SecretStrInput(name="wallet_password", display_name="Wallet Password", required=False, advanced=True),
+        DictInput(
+            name="connection_params",
+            display_name="Additional Connection Parameters",
+            info="Non-secret arguments passed to python-oracledb connect(), such as config_dir and wallet_location.",
+            list=True,
+            required=False,
+            advanced=True,
+        ),
+        DictInput(
+            name="embedding_params",
+            display_name="Embedding Parameters",
+            list=True,
+            info=(
+                "https://docs.oracle.com/en/database/oracle/oracle-database/23/vecse/utl_to_embedding-and-utl_to_embeddings-dbms_vector.html"
+            ),
+        ),
+        SecretStrInput(name="proxy", display_name="Proxy", required=False, advanced=True),
+    ]
+
+    outputs = [
+        Output(display_name="Embeddings", name="embeddings", method="build_embeddings"),
+    ]
+
+    def build_template_config(self) -> dict[str, Any]:
+        return self.get_template_config(self)
+
+    def build_embeddings(self) -> Embeddings:
+        connection_params = build_connection_params(
+            self.connection_params,
+            user=self.user,
+            password=self.password,
+            dsn=self.dsn,
+            wallet_password=self.wallet_password,
+        )
+        connection = oracledb.connect(**connection_params)
+
+        try:
+            return OracleEmbeddings(
+                conn=connection,
+                params=self.embedding_params,
+                proxy=self.proxy or None,
+            )
+        except Exception as e:
+            with suppress(Exception):
+                connection.close()
+            msg = "Unable to create OracleEmbeddings."
+            raise ValueError(msg) from e

lfx_oracle/components/oracle/oracledb_loaders.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+from typing import Any
+
+import oracledb
+from langchain_oracledb.document_loaders import OracleAutonomousDatabaseLoader, OracleDocLoader
+from lfx.custom.custom_component.component import Component
+from lfx.io import DictInput, MultilineInput, Output, SecretStrInput, StrInput
+from lfx.schema.data import Data
+
+from .connection import build_connection_params, split_credentialized_dsn
+
+
+class OracleDocLoaderComponent(Component):
+    display_name = "Oracle Doc Loader"
+    description = "Read documents from Oracle Database using OracleDocLoader."
+    documentation = "https://docs.langchain.com/oss/python/integrations/document_loaders/oracleai"
+    trace_type = "tool"
+    icon = "Oracle"
+    name = "OracleDocLoader"
+
+    inputs = [
+        SecretStrInput(name="user", display_name="User", required=False),
+        SecretStrInput(name="password", display_name="Password", required=False),
+        SecretStrInput(name="dsn", display_name="DSN", required=True),
+        SecretStrInput(name="wallet_password", display_name="Wallet Password", required=False, advanced=True),
+        DictInput(
+            name="connection_params",
+            display_name="Additional Connection Parameters",
+            info="Non-secret arguments passed to python-oracledb connect(), such as config_dir and wallet_location.",
+            required=False,
+            advanced=True,
+        ),
+        DictInput(
+            name="params",
+            display_name="Loader Parameters",
+            info="Arguments passed to langchain-oracledb OracleDocLoader.",
+            required=True,
+        ),
+    ]
+
+    outputs = [
+        Output(name="data", display_name="JSON", method="load_documents"),
+    ]
+
+    def build_template_config(self) -> dict[str, Any]:
+        return self.get_template_config(self)
+
+    def load_documents(self) -> list[Data]:
+        connection_params = build_connection_params(
+            self.connection_params,
+            user=self.user,
+            password=self.password,
+            dsn=self.dsn,
+            wallet_password=self.wallet_password,
+        )
+        with oracledb.connect(**connection_params) as connection:
+            loader = OracleDocLoader(connection, self.params)
+            data = [Data.from_document(doc) for doc in loader.load()]
+
+        self.status = data
+        return data
+
+
+class OracleAutonomousDatabaseLoaderComponent(Component):
+    display_name = "Oracle Autonomous Database Loader"
+    description = "Load rows from Oracle Autonomous Database as documents."
+    documentation = (
+        "https://github.com/oracle/langchain-oracle/blob/main/libs/oracledb/"
+        "langchain_oracledb/document_loaders/oracleadb_loader.py"
+    )
+    trace_type = "tool"
+    icon = "Oracle"
+    name = "OracleAutonomousDatabaseLoader"
+
+    inputs = [
+        StrInput(
+            name="query",
+            display_name="SQL Query",
+            required=True,
+            info="SQL query to execute. Each row becomes a document.",
+        ),
+        SecretStrInput(name="user", display_name="User", required=False),
+        SecretStrInput(name="password", display_name="Password", required=False),
+        SecretStrInput(name="dsn", display_name="DSN", required=True),
+        SecretStrInput(name="wallet_password", display_name="Wallet Password", required=False, advanced=True),
+        DictInput(
+            name="connection_params",
+            display_name="Additional Connection Parameters",
+            info="Non-secret Oracle options such as schema, config_dir, and wallet_location.",
+            required=False,
+            advanced=True,
+        ),
+        MultilineInput(
+            name="metadata",
+            display_name="Metadata Columns",
+            required=False,
+            advanced=True,
+            info="Comma-separated list of result columns to copy into document metadata.",
+        ),
+        DictInput(
+            name="parameter",
+            display_name="Bind Parameters",
+            required=False,
+            advanced=True,
+            info="Bind variables for the SQL query.",
+        ),
+    ]
+
+    outputs = [
+        Output(name="data", display_name="JSON", method="load_documents"),
+    ]
+
+    def build_template_config(self) -> dict[str, Any]:
+        """Build template config from this class to avoid cross-class metadata bleed."""
+        return self.get_template_config(self)
+
+    def _parse_metadata(self) -> list[str] | None:
+        metadata = getattr(self, "metadata", None)
+        if metadata is None:
+            return None
+        if isinstance(metadata, str):
+            values = [column.strip() for column in metadata.split(",") if column.strip()]
+            return values or None
+        if isinstance(metadata, list):
+            return metadata or None
+        return None
+
+    def _parse_connection_params(self) -> dict[str, Any]:
+        connection_params = build_connection_params(
+            self.connection_params,
+            user=self.user,
+            password=self.password,
+            dsn=self.dsn,
+            wallet_password=self.wallet_password,
+        )
+        dsn = connection_params.get("dsn") or connection_params.get("connection_string") or connection_params.get("tns")
+
+        user = connection_params.get("user") or connection_params.get("username")
+        password = connection_params.get("password")
+
+        if isinstance(dsn, str) and (not user or not password):
+            parsed_user, parsed_password, parsed_dsn = split_credentialized_dsn(dsn)
+            user = user or parsed_user
+            password = password or parsed_password
+            dsn = parsed_dsn
+
+        if not user or not password:
+            msg = (
+                "Connection settings must include user and password, either in the dedicated fields or inside the DSN."
+            )
+            raise ValueError(msg)
+
+        return {
+            "user": user,
+            "password": password,
+            "dsn": dsn,
+            "schema": connection_params.get("schema"),
+            "config_dir": connection_params.get("config_dir"),
+            "wallet_location": connection_params.get("wallet_location"),
+            "wallet_password": connection_params.get("wallet_password"),
+        }
+
+    def _parse_parameter(self) -> Any:
+        parameter = getattr(self, "parameter", None)
+        return parameter or None
+
+    def load_documents(self) -> list[Data]:
+        loader = OracleAutonomousDatabaseLoader(
+            query=self.query,
+            metadata=self._parse_metadata(),
+            parameter=self._parse_parameter(),
+            **self._parse_connection_params(),
+        )
+
+        data = [Data.from_document(doc) for doc in loader.load()]
+        self.status = data
+        return data

lfx_oracle/components/oracle/oraclevs.py

@@ -0,0 +1,246 @@
+import hashlib
+import json
+from contextlib import suppress
+from decimal import Decimal
+from importlib.metadata import version
+from typing import Any
+
+import oracledb
+from langchain_community.vectorstores.utils import DistanceStrategy
+from langchain_oracledb.vectorstores import OracleVS
+from langchain_oracledb.vectorstores.oraclevs import create_index
+from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
+from lfx.helpers.data import docs_to_data
+from lfx.io import BoolInput, DictInput, DropdownInput, HandleInput, IntInput, Output, SecretStrInput, StrInput
+from lfx.schema.data import Data
+from pydantic import BaseModel
+
+from .connection import build_connection_params
+
+
+def serialize(obj: Any) -> dict | list:
+    if isinstance(obj, BaseModel):
+        return obj.model_dump(mode="json")
+    if isinstance(obj, dict):
+        return {k: serialize(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [serialize(item) for item in obj]
+    if isinstance(obj, tuple):
+        return [serialize(item) for item in obj]
+    return obj
+
+
+def normalize_search_result(obj: Any) -> Any:
+    if isinstance(obj, Decimal):
+        return float(obj)
+    if isinstance(obj, dict):
+        return {key: normalize_search_result(value) for key, value in obj.items()}
+    if isinstance(obj, list):
+        return [normalize_search_result(item) for item in obj]
+    if isinstance(obj, tuple):
+        return [normalize_search_result(item) for item in obj]
+    return obj
+
+
+class OracleVectorStoreComponent(LCVectorStoreComponent):
+    display_name = "Oracle Vector Store"
+    description = "Oracle vector store with search capabilities"
+    name = "OracleVS"
+    icon = "Oracle"
+
+    inputs = [
+        SecretStrInput(name="user", display_name="User", required=False),
+        SecretStrInput(name="password", display_name="Password", required=False),
+        SecretStrInput(name="dsn", display_name="DSN", required=True),
+        SecretStrInput(name="wallet_password", display_name="Wallet Password", required=False, advanced=True),
+        DictInput(
+            name="connection_params",
+            display_name="Additional Connection Parameters",
+            info="Non-secret arguments passed to python-oracledb connect(), such as config_dir and wallet_location.",
+            list=True,
+            required=False,
+            advanced=True,
+        ),
+        StrInput(name="table_name", display_name="Table Name", required=True),
+        *LCVectorStoreComponent.inputs,
+        HandleInput(name="embedding", display_name="Embedding", input_types=["Embeddings"], required=True),
+        IntInput(
+            name="number_of_results",
+            display_name="Number of Results",
+            info="Number of results to return.",
+            value=4,
+            advanced=True,
+        ),
+        DropdownInput(
+            name="search_type",
+            display_name="Search Type",
+            info="Search type to use",
+            options=["Similarity", "MMR (Max Marginal Relevance)"],
+            value="Similarity",
+            advanced=True,
+        ),
+        DropdownInput(
+            name="distance_strategy",
+            display_name="Distance Strategy",
+            options=["EUCLIDEAN", "DOT", "COSINE"],
+            value="COSINE",
+            advanced=True,
+        ),
+        BoolInput(
+            name="create_index",
+            display_name="Create Vector Index",
+            info=(
+                "Boolean flag to determine whether to create a vector index. "
+                "Check `Controls` to use advanced parameters."
+            ),
+            value=True,
+        ),
+        DictInput(
+            name="index_params",
+            display_name="Vector Index Parameters",
+            list=True,
+            advanced=True,
+        ),
+        BoolInput(
+            name="mutate_on_duplicate",
+            display_name="Mutate on Duplicate Inserts",
+            info="Whether to update existing rows when duplicate inserts are encountered.",
+            value=False,
+            advanced=True,
+        ),
+    ]
+
+    # Mirrors LCVectorStoreComponent.outputs verbatim: the extension
+    # validator statically scans this file and cannot see inherited
+    # outputs, so the declaration must be repeated here.
+    outputs = [
+        Output(
+            display_name="Search Results",
+            name="search_results",
+            method="search_documents",
+            info=(
+                "Performs semantic similarity search in the vector store to find relevant documents/files. "
+                "Input: A natural language search query (str). "
+                "Returns: A list of Data objects (dicts). Each result has structure: {'data': {'text': '...', ...}}. "
+                "The 'text' field always contains the matched document content. "
+                "Other metadata fields depend on what was indexed "
+                "(may include: 'file_path', 'source', 'page', etc.). "
+                "IMPORTANT: To extract metadata like file_path, use: "
+                "result['data'].get('file_path') or result.data.get('file_path'). "
+                "Check what fields are available by inspecting result['data'].keys() or the first search result."
+            ),
+            tool_mode=True,
+        ),
+        Output(
+            display_name="Table",
+            name="dataframe",
+            method="as_dataframe",
+        ),
+    ]
+
+    def build_template_config(self) -> dict[str, Any]:
+        return self.get_template_config(self)
+
+    @check_cached_vector_store
+    def build_vector_store(self) -> OracleVS:
+        # Convert DataFrame to Data if needed using parent's method
+        self.ingest_data = self._prepare_ingest_data()
+
+        documents = []
+        for _input in self.ingest_data or []:
+            inp = _input
+            if isinstance(_input, Data):
+                inp = _input.to_lc_document()
+
+            if hasattr(inp, "metadata"):
+                inp.metadata = serialize(inp.metadata)
+
+            documents.append(inp)
+
+        opened_connection = False
+        if (not hasattr(self, "connection")) or (not self.connection):
+            connection_params = build_connection_params(
+                self.connection_params,
+                user=self.user,
+                password=self.password,
+                dsn=self.dsn,
+                wallet_password=self.wallet_password,
+            )
+            self.connection = oracledb.connect(**connection_params)
+            opened_connection = True
+
+        distance_strategy2function = {
+            "EUCLIDEAN": DistanceStrategy.EUCLIDEAN_DISTANCE,
+            "DOT": DistanceStrategy.DOT_PRODUCT,
+            "COSINE": DistanceStrategy.COSINE,
+        }
+        distance_strategy = distance_strategy2function[self.distance_strategy]
+
+        params = {
+            "client": self.connection,
+            "table_name": self.table_name,
+            "distance_strategy": distance_strategy,
+        }
+
+        if not version("langchain_oracledb").startswith("1.0"):
+            params["mutate_on_duplicate"] = self.mutate_on_duplicate
+
+        try:
+            if documents:
+                vs = OracleVS.from_documents(embedding=self.embedding, documents=documents, **params)
+            else:
+                vs = OracleVS(embedding_function=self.embedding, **params)
+
+            if self.create_index:
+                index_params = (self.index_params or {}).copy()
+
+                if "idx_name" not in index_params:
+                    params_str = json.dumps(index_params, sort_keys=True)
+                    distance_strategy = self.distance_strategy
+                    params_str = params_str + distance_strategy
+                    index_name = params["table_name"] + "_idx_" + hashlib.sha256(params_str.encode()).hexdigest()[:16]
+                    index_params["idx_name"] = index_name
+
+                if "idx_type" not in index_params:
+                    index_params["idx_type"] = "HNSW"
+
+                if "" in index_params:
+                    del index_params[""]
+                create_index(self.connection, vs, index_params)
+        except Exception:
+            if opened_connection:
+                with suppress(Exception):
+                    self.connection.close()
+                self.connection = None
+            raise
+
+        return vs
+
+    def _map_search_type(self) -> str:
+        if self.search_type == "MMR (Max Marginal Relevance)":
+            return "mmr"
+        return "similarity"
+
+    def _build_search_args(self) -> dict[str, Any]:
+        return {"k": self.number_of_results}
+
+    def search_documents(self) -> list[Data]:
+        raw_search_query = getattr(self, "search_query", None)
+        search_query = str(raw_search_query).strip() if raw_search_query is not None else ""
+
+        if not search_query:
+            self.status = []
+            return []
+
+        vector_store = self.build_vector_store()
+        docs = vector_store.search(
+            query=search_query,
+            search_type=self._map_search_type(),
+            **self._build_search_args(),
+        )
+
+        data = docs_to_data(docs)
+        for item in data:
+            item.data = normalize_search_result(item.data)
+        self.status = data
+        return data

lfx_oracle/extension.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://schemas.langflow.org/extension/v1.json",
+  "id": "lfx-oracle",
+  "version": "0.1.0",
+  "name": "Oracle",
+  "description": "Oracle component(s) as a standalone Langflow Extension Bundle.",
+  "lfx": {
+    "compat": ["1"]
+  },
+  "bundles": [
+    {
+      "name": "oracle",
+      "path": "components/oracle"
+    }
+  ]
+}

lfx_oracle-0.1.0.dist-info/METADATA

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: lfx-oracle
+Version: 0.1.0
+Summary: Oracle Database components (Doc Loader, Autonomous Database Loader, Embeddings, Vector Store) 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,oracle,oracledb,vector-store
+Requires-Python: <3.15,>=3.10
+Requires-Dist: langchain-community<1.0.0,>=0.4.1
+Requires-Dist: langchain-oracledb<2.0.0,>=1.0.1
+Requires-Dist: lfx<2.0.0,>=1.11.0.dev0
+Requires-Dist: oracledb<4.0.0,>=2.2.0
+Description-Content-Type: text/markdown
+
+# lfx-oracle
+
+Oracle Database components (Doc Loader, Autonomous Database Loader,
+Embeddings, Vector Store) as a standalone Langflow Extension Bundle.
+
+## Install
+
+```bash
+pip install lfx-oracle
+```
+
+The bundle is registered automatically via the `langflow.extensions`
+entry-point.  After install, restart your Langflow server; the bundle's
+components will appear in the palette under the `Oracle` group.
+
+## Develop
+
+```bash
+cd src/bundles/oracle
+pip install -e .
+lfx extension validate src/lfx_oracle
+```
+
+## Migration
+
+Saved flows referencing the legacy class name(s) or the old import paths
+under `lfx.components.oracledb.*` are rewritten to the new namespaced
+IDs by the migration table in
+`src/lfx/src/lfx/extension/migration/migration_table.json`.

lfx_oracle-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+lfx_oracle/__init__.py,sha256=YFjqnOfX-NwVbqX_sUbODKfHtfaGpOf-In3RrmSs2lg,735
+lfx_oracle/extension.json,sha256=mKatK928YRWMnI7FpxlIR6Etjo56WJUvhmXLMUb29c8,339
+lfx_oracle/components/oracle/__init__.py,sha256=j6jLNObRB-mfQlnemFPWN81sZ1r-xjz1e0onvpnPWrA,632
+lfx_oracle/components/oracle/connection.py,sha256=6zFIFTsvsnUUVkfKwMytlZ9eYYdcGN2etPxZ9-eUu74,2377
+lfx_oracle/components/oracle/oracledb_embeddings.py,sha256=SIY1OjOMYXR_sX7X9A5S4d416qziecDyC47GtKdxqgs,2562
+lfx_oracle/components/oracle/oracledb_loaders.py,sha256=GRCPuuO1b9MxoF6V-1fKAuxbBokRxbBZ9hM0si8D2Hw,6742
+lfx_oracle/components/oracle/oraclevs.py,sha256=MxBd9hWOy4OFupLyrADiXUbXJEZfEhcZxKueQsJDss8,9258
+lfx_oracle-0.1.0.dist-info/METADATA,sha256=15gA-JmbYUZjRUFII4194aWwXOAD9hZ7Le9bG40wIBk,1521
+lfx_oracle-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+lfx_oracle-0.1.0.dist-info/entry_points.txt,sha256=BJ7HwFhchI9erTGgLTs--q9cHK2xQVBgQLL3g5DXbZA,46
+lfx_oracle-0.1.0.dist-info/RECORD,,

lfx_oracle-0.1.0.dist-info/WHEEL

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

lfx_oracle-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[langflow.extensions]
+lfx-oracle = lfx_oracle