lfx-valkey 0.1.0__py3-none-any.whl

lfx_valkey/__init__.py

@@ -0,0 +1,15 @@
+"""lfx-valkey: Valkey bundle.
+
+Distribution unit ``lfx-valkey``.  At runtime Langflow's loader
+discovers ``extension.json`` shipped alongside this ``__init__.py`` and
+registers the bundle's components under the namespaced IDs
+``ext:valkey:<Class>@official``.
+"""
+
+from lfx_valkey.components.valkey.valkey import ValkeyVectorStoreComponent
+from lfx_valkey.components.valkey.valkey_chat import ValkeyIndexChatMemory
+
+__all__ = [
+    "ValkeyIndexChatMemory",
+    "ValkeyVectorStoreComponent",
+]

lfx_valkey/components/valkey/__init__.py

@@ -0,0 +1,45 @@
+"""Lazy component re-exports for the ``valkey`` bundle.
+
+Mirrors the pre-extraction layout of ``lfx.components.valkey`` so saved
+flows that referenced the module-level class
+(e.g. ``lfx.components.valkey.<Class>``) keep resolving via the
+migration table after rewrite to
+``lfx_valkey.components.valkey.<Class>``.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .valkey import ValkeyVectorStoreComponent
+    from .valkey_chat import ValkeyIndexChatMemory
+
+_dynamic_imports = {
+    "ValkeyIndexChatMemory": "valkey_chat",
+    "ValkeyVectorStoreComponent": "valkey",
+}
+
+__all__ = [
+    "ValkeyIndexChatMemory",
+    "ValkeyVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    if attr_name not in _dynamic_imports:
+        msg = f"module {__name__!r} has no attribute {attr_name!r}"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import {attr_name!r} from {__name__!r}: {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx_valkey/components/valkey/valkey.py

@@ -0,0 +1,143 @@
+import structlog
+from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
+from lfx.helpers.data import docs_to_data
+from lfx.io import HandleInput, IntInput, SecretStrInput, StrInput
+from lfx.schema.data import Data
+
+logger = structlog.get_logger(__name__)
+
+
+def _patch_check_index_exists():
+    """Patch langchain-aws check_index_exists to handle valkey-glide RequestError.
+
+    langchain-aws's check_index_exists only catches KeyError/ValueError/RuntimeError,
+    but valkey-glide raises glide_shared.exceptions.RequestError when an index doesn't
+    exist. This patch catches that specific exception so _create_index_if_not_exist
+    can proceed to create the index.
+
+    This is a workaround until langchain-aws handles the GLIDE exception itself.
+    """
+    try:
+        import langchain_aws.vectorstores.valkey.base as _valkey_base
+    except (ImportError, AttributeError):
+        return
+
+    if getattr(_valkey_base, "patched_check_index_exists", False):
+        return
+
+    try:
+        from glide_shared.exceptions import RequestError as GlideRequestError
+    except ImportError:
+        return
+
+    _original_check = _valkey_base.check_index_exists
+
+    def _patched_check(client, index_name):
+        try:
+            return _original_check(client, index_name)
+        except GlideRequestError:
+            logger.debug("Valkey index does not exist yet", index_name=index_name)
+            return False
+
+    _valkey_base.check_index_exists = _patched_check
+    _valkey_base.patched_check_index_exists = True
+
+
+class ValkeyVectorStoreComponent(LCVectorStoreComponent):
+    """A custom component for implementing a Vector Store using Valkey."""
+
+    display_name: str = "Valkey"
+    description: str = "Implementation of Vector Store using Valkey"
+    name = "Valkey"
+    icon = "Valkey"
+
+    inputs = [
+        SecretStrInput(name="valkey_server_url", display_name="Valkey Server Connection String", required=True),
+        StrInput(name="valkey_index_name", display_name="Valkey Index"),
+        *LCVectorStoreComponent.inputs,
+        IntInput(
+            name="number_of_results",
+            display_name="Number of Results",
+            info="Number of results to return.",
+            value=4,
+            advanced=True,
+        ),
+        HandleInput(name="embedding", display_name="Embedding", input_types=["Embeddings"]),
+    ]
+
+    @check_cached_vector_store
+    def build_vector_store(self):
+        import json
+
+        # Imported lazily because it pulls valkey-glide, which ships no Windows
+        # wheels -- the ``valkey`` extra of langchain-aws is gated off Windows
+        # via the platform marker in this bundle's pyproject.toml.  Keeping the
+        # import out of module scope lets the bundle load on Windows even though
+        # this vector store cannot run there; the Valkey Chat Memory component
+        # (redis-py based) still works.
+        try:
+            from langchain_aws.vectorstores import ValkeyVectorStore
+        except ImportError as e:
+            msg = (
+                "Could not import valkey-glide, which backs the Valkey Vector Store. "
+                "It ships no Windows wheels and is not installed on Windows; run this "
+                "component on Linux or macOS. Elsewhere, install it with "
+                "'pip install langchain-aws[valkey]'."
+            )
+            raise ImportError(msg) from e
+
+        _patch_check_index_exists()
+
+        self.ingest_data = self._prepare_ingest_data()
+
+        documents = []
+        for _input in self.ingest_data or []:
+            if isinstance(_input, Data):
+                documents.append(_input.to_lc_document())
+            else:
+                documents.append(_input)
+
+        # Filter out documents with empty page_content — embedding models
+        # (e.g. Bedrock) reject zero-length input strings.
+        valid_documents = []
+        for doc in documents:
+            content = getattr(doc, "page_content", None) or ""
+            if content.strip():
+                valid_documents.append(doc)
+            elif doc.metadata:
+                doc.page_content = json.dumps(doc.metadata, default=str)
+                valid_documents.append(doc)
+            else:
+                logger.warning("Valkey: skipping document with no content and no metadata")
+        documents = valid_documents
+
+        if not documents:
+            if not self.valkey_index_name:
+                msg = "If no documents are provided, an index name must be provided."
+                raise ValueError(msg)
+
+            return ValkeyVectorStore.from_existing_index(
+                embedding=self.embedding,
+                valkey_url=self.valkey_server_url,
+                index_name=self.valkey_index_name,
+            )
+
+        return ValkeyVectorStore.from_documents(
+            documents=documents,
+            embedding=self.embedding,
+            valkey_url=self.valkey_server_url,
+            index_name=self.valkey_index_name,
+        )
+
+    def search_documents(self) -> list[Data]:
+        vector_store = self.build_vector_store()
+
+        if self.search_query and isinstance(self.search_query, str) and self.search_query.strip():
+            docs = vector_store.similarity_search(
+                query=self.search_query,
+                k=self.number_of_results,
+            )
+            data = docs_to_data(docs)
+            self.status = data
+            return data
+        return []

lfx_valkey/components/valkey/valkey_chat.py

@@ -0,0 +1,62 @@
+from urllib import parse
+
+from lfx.base.memory.model import LCChatMemoryComponent
+from lfx.field_typing.constants import Memory
+from lfx.inputs.inputs import IntInput, MessageTextInput, SecretStrInput, StrInput
+
+
+class ValkeyIndexChatMemory(LCChatMemoryComponent):
+    display_name = "Valkey Chat Memory"
+    description = "Retrieves and stores chat messages from Valkey."
+    name = "ValkeyChatMemory"
+    icon = "Valkey"
+
+    inputs = [
+        StrInput(
+            name="host", display_name="Hostname", required=True, value="localhost", info="IP address or hostname."
+        ),
+        IntInput(name="port", display_name="Port", required=True, value=6379, info="Valkey Port Number."),
+        StrInput(name="database", display_name="Database", required=True, value="0", info="Valkey database."),
+        MessageTextInput(
+            name="username", display_name="Username", value="", info="The Valkey user name.", advanced=True
+        ),
+        SecretStrInput(
+            name="password",
+            display_name="Valkey Password",
+            info="Password for the specified username.",
+            advanced=True,
+            load_from_db=False,
+        ),
+        StrInput(name="key_prefix", display_name="Key prefix", info="Key prefix.", advanced=True),
+        MessageTextInput(
+            name="session_id", display_name="Session ID", info="Session ID for the message.", advanced=True
+        ),
+    ]
+
+    def build_message_history(self) -> Memory:
+        from langchain_community.chat_message_histories.redis import RedisChatMessageHistory
+
+        kwargs = {}
+        if self.key_prefix:
+            kwargs["key_prefix"] = self.key_prefix
+
+        # Build URL, only include auth if credentials are actually provided
+        password = getattr(self, "password", None)
+        username = getattr(self, "username", None)
+        has_password = bool(password) and str(password).strip() not in ("", "None")
+        has_username = bool(username) and str(username).strip() not in ("", "None")
+
+        if has_password:
+            # Use quote(safe="") so every reserved char (space, +, /, :, @) is
+            # percent-encoded. redis-py's from_url parses the URL with urlparse
+            # and decodes credentials with unquote (not unquote_plus), so
+            # quote_plus would turn a space into "+" and round-trip to a wrong
+            # password.
+            encoded_pw = parse.quote(str(password), safe="")
+            encoded_username = parse.quote(str(username), safe="") if has_username else ""
+            auth = f"{encoded_username}:{encoded_pw}@"
+        else:
+            auth = ""
+
+        url = f"redis://{auth}{self.host}:{self.port}/{self.database}"
+        return RedisChatMessageHistory(session_id=self.session_id, url=url, **kwargs)

lfx_valkey/extension.json

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

lfx_valkey-0.1.0.dist-info/METADATA

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: lfx-valkey
+Version: 0.1.0
+Summary: Valkey component(s) 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,valkey
+Requires-Python: <3.15,>=3.10
+Requires-Dist: langchain-aws<2.0.0,>=1.4.1; sys_platform == 'win32'
+Requires-Dist: langchain-aws[valkey]<2.0.0,>=1.4.1; sys_platform != 'win32'
+Requires-Dist: langchain-community<1.0.0,>=0.4.1
+Requires-Dist: lfx<2.0.0,>=1.11.0.dev0
+Requires-Dist: redis<8.0.0,>=7.4.0
+Requires-Dist: structlog<26.0.0,>=25.4.0
+Description-Content-Type: text/markdown
+
+# lfx-valkey
+
+Valkey component(s) as a standalone Langflow Extension Bundle.
+
+## Install
+
+```bash
+pip install lfx-valkey
+```
+
+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 `valkey` group with
+the namespaced IDs `ext:valkey:<Class>@official`.
+
+## Develop
+
+```bash
+cd src/bundles/valkey
+pip install -e .
+lfx extension validate src/lfx_valkey
+```
+
+## Migration
+
+Saved flows referencing the legacy class name(s) or the old import paths
+under `lfx.components.valkey.*` are rewritten to the new namespaced
+IDs by the migration table in
+`src/lfx/src/lfx/extension/migration/migration_table.json`.

lfx_valkey-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+lfx_valkey/__init__.py,sha256=dMLv1-FD9nXNuFmcmT0EhM144Q-jLin1liPr7q3VY7I,492
+lfx_valkey/extension.json,sha256=0mA53PZCLS7awsSGVIkYSbrIivcg6cKCr_i2heNM2Jo,339
+lfx_valkey/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lfx_valkey/components/valkey/__init__.py,sha256=tlutRPy8SOLsiGIq5rP77JkEO12M1VTlhQTPrm10Y6E,1320
+lfx_valkey/components/valkey/valkey.py,sha256=kQDK3HOoKUgYT5nNV5abAc0sF1CDxBscC567vOtdQ4Q,5445
+lfx_valkey/components/valkey/valkey_chat.py,sha256=HO-EUS9304gVptBZFzZLeYG2NiHhzrinrDzn4eXQ3w0,2771
+lfx_valkey-0.1.0.dist-info/METADATA,sha256=JtzAdg6NO4EMNJFfAz4y2iT62DkpGbRHg3uwmHCTS4Q,1537
+lfx_valkey-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+lfx_valkey-0.1.0.dist-info/entry_points.txt,sha256=Qj9LWe52n0t0zzzYlzbau-b5QcboVEz4_h1XZETPTr4,46
+lfx_valkey-0.1.0.dist-info/RECORD,,

lfx_valkey-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_valkey-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[langflow.extensions]
+lfx-valkey = lfx_valkey