lfx-nightly 0.2.0.dev0__py3-none-any.whl → 0.2.0.dev41__py3-none-any.whl

lfx/components/langchain_utilities/csv_agent.py

@@ -1,6 +1,9 @@
-from langchain_experimental.agents.agent_toolkits.csv.base import create_csv_agent
+import contextlib
+import tempfile
+from pathlib import Path
 
 from lfx.base.agents.agent import LCAgentComponent
+from lfx.base.data.storage_utils import read_file_bytes
 from lfx.field_typing import AgentExecutor
 from lfx.inputs.inputs import (
     DictInput,
@@ -10,7 +13,9 @@ from lfx.inputs.inputs import (
     MessageTextInput,
 )
 from lfx.schema.message import Message
+from lfx.services.deps import get_settings_service
 from lfx.template.field.base import Output
+from lfx.utils.async_helpers import run_until_complete
 
 
 class CSVAgentComponent(LCAgentComponent):
@@ -70,32 +75,60 @@ class CSVAgentComponent(LCAgentComponent):
         return self.path
 
     def build_agent_response(self) -> Message:
-        agent_kwargs = {
-            "verbose": self.verbose,
-            "allow_dangerous_code": True,
-        }
+        """Build and execute the CSV agent, returning the response."""
+        try:
+            from langchain_experimental.agents.agent_toolkits.csv.base import create_csv_agent
+        except ImportError as e:
+            msg = (
+                "langchain-experimental is not installed. Please install it with `pip install langchain-experimental`."
+            )
+            raise ImportError(msg) from e
 
-        agent_csv = create_csv_agent(
-            llm=self.llm,
-            path=self._path(),
-            agent_type=self.agent_type,
-            handle_parsing_errors=self.handle_parsing_errors,
-            pandas_kwargs=self.pandas_kwargs,
-            **agent_kwargs,
-        )
+        try:
+            agent_kwargs = {
+                "verbose": self.verbose,
+                "allow_dangerous_code": True,
+            }
+
+            # Get local path (downloads from S3 if needed)
+            local_path = self._get_local_path()
 
-        result = agent_csv.invoke({"input": self.input_value})
-        return Message(text=str(result["output"]))
+            agent_csv = create_csv_agent(
+                llm=self.llm,
+                path=local_path,
+                agent_type=self.agent_type,
+                handle_parsing_errors=self.handle_parsing_errors,
+                pandas_kwargs=self.pandas_kwargs,
+                **agent_kwargs,
+            )
+
+            result = agent_csv.invoke({"input": self.input_value})
+            return Message(text=str(result["output"]))
+
+        finally:
+            # Clean up temp file if created
+            self._cleanup_temp_file()
 
     def build_agent(self) -> AgentExecutor:
+        try:
+            from langchain_experimental.agents.agent_toolkits.csv.base import create_csv_agent
+        except ImportError as e:
+            msg = (
+                "langchain-experimental is not installed. Please install it with `pip install langchain-experimental`."
+            )
+            raise ImportError(msg) from e
+
         agent_kwargs = {
             "verbose": self.verbose,
             "allow_dangerous_code": True,
         }
 
+        # Get local path (downloads from S3 if needed)
+        local_path = self._get_local_path()
+
         agent_csv = create_csv_agent(
             llm=self.llm,
-            path=self._path(),
+            path=local_path,
             agent_type=self.agent_type,
             handle_parsing_errors=self.handle_parsing_errors,
             pandas_kwargs=self.pandas_kwargs,
@@ -104,4 +137,39 @@ class CSVAgentComponent(LCAgentComponent):
 
         self.status = Message(text=str(agent_csv))
 
+        # Note: Temp file will be cleaned up when the component is destroyed or
+        # when build_agent_response is called
         return agent_csv
+
+    def _get_local_path(self) -> str:
+        """Get a local file path, downloading from S3 storage if necessary.
+
+        Returns:
+            str: Local file path that can be used by LangChain
+        """
+        file_path = self._path()
+        settings = get_settings_service().settings
+
+        # If using S3 storage, download the file to temp
+        if settings.storage_type == "s3":
+            # Download from S3 to temp file
+            csv_bytes = run_until_complete(read_file_bytes(file_path))
+
+            # Create temp file with .csv extension
+            suffix = Path(file_path.split("/")[-1]).suffix or ".csv"
+            with tempfile.NamedTemporaryFile(mode="wb", suffix=suffix, delete=False) as tmp_file:
+                tmp_file.write(csv_bytes)
+                temp_path = tmp_file.name
+
+            # Store temp path for cleanup
+            self._temp_file_path = temp_path
+            return temp_path
+
+        # Local storage - return path as-is
+        return file_path
+
+    def _cleanup_temp_file(self) -> None:
+        """Clean up temporary file if one was created."""
+        if hasattr(self, "_temp_file_path"):
+            with contextlib.suppress(Exception):
+                Path(self._temp_file_path).unlink()  # Ignore cleanup errors

lfx/components/langchain_utilities/json_agent.py

@@ -1,13 +1,15 @@
+import contextlib
+import tempfile
 from pathlib import Path
 
 import yaml
 from langchain.agents import AgentExecutor
-from langchain_community.agent_toolkits import create_json_agent
-from langchain_community.agent_toolkits.json.toolkit import JsonToolkit
-from langchain_community.tools.json.tool import JsonSpec
 
 from lfx.base.agents.agent import LCAgentComponent
+from lfx.base.data.storage_utils import read_file_bytes
 from lfx.inputs.inputs import FileInput, HandleInput
+from lfx.services.deps import get_settings_service
+from lfx.utils.async_helpers import run_until_complete
 
 
 class JsonAgentComponent(LCAgentComponent):
@@ -32,14 +34,67 @@ class JsonAgentComponent(LCAgentComponent):
         ),
     ]
 
+    def _get_local_path(self) -> Path:
+        """Get a local file path, downloading from S3 storage if necessary.
+
+        Returns:
+            Path: Local file path that can be used by LangChain
+        """
+        file_path = self.path
+        settings = get_settings_service().settings
+
+        # If using S3 storage, download the file to temp
+        if settings.storage_type == "s3":
+            # Download from S3 to temp file
+            file_bytes = run_until_complete(read_file_bytes(file_path))
+
+            # Create temp file with appropriate extension
+            suffix = Path(file_path.split("/")[-1]).suffix or ".json"
+            with tempfile.NamedTemporaryFile(mode="wb", suffix=suffix, delete=False) as tmp_file:
+                tmp_file.write(file_bytes)
+                temp_path = tmp_file.name
+
+            # Store temp path for cleanup
+            self._temp_file_path = temp_path
+            return Path(temp_path)
+
+        # Local storage - return as Path
+        return Path(file_path)
+
+    def _cleanup_temp_file(self) -> None:
+        """Clean up temporary file if one was created."""
+        if hasattr(self, "_temp_file_path"):
+            with contextlib.suppress(Exception):
+                Path(self._temp_file_path).unlink()  # Ignore cleanup errors
+
     def build_agent(self) -> AgentExecutor:
-        path = Path(self.path)
-        if path.suffix in {"yaml", "yml"}:
-            with path.open(encoding="utf-8") as file:
-                yaml_dict = yaml.safe_load(file)
-            spec = JsonSpec(dict_=yaml_dict)
-        else:
-            spec = JsonSpec.from_file(path)
-        toolkit = JsonToolkit(spec=spec)
+        """Build the JSON agent executor."""
+        try:
+            from langchain_community.agent_toolkits import create_json_agent
+            from langchain_community.agent_toolkits.json.toolkit import JsonToolkit
+            from langchain_community.tools.json.tool import JsonSpec
+        except ImportError as e:
+            msg = "langchain-community is not installed. Please install it with `pip install langchain-community`."
+            raise ImportError(msg) from e
+
+        try:
+            # Get local path (downloads from S3 if needed)
+            path = self._get_local_path()
 
-        return create_json_agent(llm=self.llm, toolkit=toolkit, **self.get_agent_kwargs())
+            if path.suffix in {".yaml", ".yml"}:
+                with path.open(encoding="utf-8") as file:
+                    yaml_dict = yaml.safe_load(file)
+                spec = JsonSpec(dict_=yaml_dict)
+            else:
+                spec = JsonSpec.from_file(str(path))
+            toolkit = JsonToolkit(spec=spec)
+
+            agent = create_json_agent(llm=self.llm, toolkit=toolkit, **self.get_agent_kwargs())
+        except Exception:
+            # Make sure to clean up temp file on error
+            self._cleanup_temp_file()
+            raise
+        else:
+            # Clean up temp file after agent is created
+            self._cleanup_temp_file()
+            return agent

lfx/components/langchain_utilities/language_recursive.py

@@ -9,7 +9,7 @@ from lfx.inputs.inputs import DataInput, DropdownInput, IntInput
 class LanguageRecursiveTextSplitterComponent(LCTextSplitterComponent):
     display_name: str = "Language Recursive Text Splitter"
     description: str = "Split text into chunks of a specified length based on language."
-    documentation: str = "https://docs.langflow.org/components/text-splitters#languagerecursivetextsplitter"
+    documentation: str = "https://docs.langflow.org/bundles-langchain"
     name = "LanguageRecursiveTextSplitter"
     icon = "LangChain"
 

lfx/components/llm_operations/__init__.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.llm_operations.batch_run import BatchRunComponent
+    from lfx.components.llm_operations.lambda_filter import SmartTransformComponent
+    from lfx.components.llm_operations.llm_conditional_router import SmartRouterComponent
+    from lfx.components.llm_operations.llm_selector import LLMSelectorComponent
+    from lfx.components.llm_operations.structured_output import StructuredOutputComponent
+
+_dynamic_imports = {
+    "BatchRunComponent": "batch_run",
+    "SmartTransformComponent": "lambda_filter",
+    "SmartRouterComponent": "llm_conditional_router",
+    "LLMSelectorComponent": "llm_selector",
+    "StructuredOutputComponent": "structured_output",
+}
+
+__all__ = [
+    "BatchRunComponent",
+    "LLMSelectorComponent",
+    "SmartRouterComponent",
+    "SmartTransformComponent",
+    "StructuredOutputComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import LLM operation components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        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}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/{processing → llm_operations}/batch_run.py

@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 class BatchRunComponent(Component):
     display_name = "Batch Run"
     description = "Runs an LLM on each row of a DataFrame column. If no column is specified, all columns are used."
-    documentation: str = "https://docs.langflow.org/components-processing#batch-run"
+    documentation: str = "https://docs.langflow.org/batch-run"
     icon = "List"
 
     inputs = [
@@ -159,13 +159,22 @@ class BatchRunComponent(Component):
             ]
 
             # Configure the model with project info and callbacks
-            model = model.with_config(
-                {
-                    "run_name": self.display_name,
-                    "project_name": self.get_project_name(),
-                    "callbacks": self.get_langchain_callbacks(),
-                }
-            )
+            # Some models (e.g., ChatWatsonx) may have serialization issues with with_config()
+            # due to SecretStr or other non-serializable attributes
+            try:
+                model = model.with_config(
+                    {
+                        "run_name": self.display_name,
+                        "project_name": self.get_project_name(),
+                        "callbacks": self.get_langchain_callbacks(),
+                    }
+                )
+            except (TypeError, ValueError, AttributeError) as e:
+                # Log warning and continue without configuration
+                await logger.awarning(
+                    f"Could not configure model with callbacks and project info: {e!s}. "
+                    "Proceeding with batch processing without configuration."
+                )
             # Process batches and track progress
             responses_with_idx = list(
                 zip(

lfx/components/{processing → llm_operations}/lambda_filter.py

@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 class LambdaFilterComponent(Component):
     display_name = "Smart Transform"
     description = "Uses an LLM to generate a function for filtering or transforming structured data."
-    documentation: str = "https://docs.langflow.org/components-processing#smart-transform"
+    documentation: str = "https://docs.langflow.org/smart-transform"
     icon = "square-function"
     name = "Smart Transform"
 

lfx/components/{logic → llm_operations}/llm_conditional_router.py

@@ -9,7 +9,7 @@ from lfx.schema.table import EditMode
 class SmartRouterComponent(Component):
     display_name = "Smart Router"
     description = "Routes an input message using LLM-based categorization."
-    icon = "equal"
+    icon = "route"
     name = "SmartRouter"
 
     def __init__(self, **kwargs):

lfx/components/{processing/llm_router.py → llm_operations/llm_selector.py}

@@ -14,10 +14,10 @@ from lfx.schema.message import Message
 from lfx.template.field.base import Output
 
 
-class LLMRouterComponent(Component):
-    display_name = "LLM Router"
+class LLMSelectorComponent(Component):
+    display_name = "LLM Selector"
     description = "Routes the input to the most appropriate LLM based on OpenRouter model specifications"
-    documentation: str = "https://docs.langflow.org/components-processing#llm-router"
+    documentation: str = "https://docs.langflow.org/llm-selector"
     icon = "git-branch"
 
     # Constants for magic values

lfx/components/{processing → llm_operations}/structured_output.py

@@ -20,7 +20,7 @@ from lfx.schema.table import EditMode
 class StructuredOutputComponent(Component):
     display_name = "Structured Output"
     description = "Uses an LLM to generate structured data. Ideal for extraction and consistency."
-    documentation: str = "https://docs.langflow.org/components-processing#structured-output"
+    documentation: str = "https://docs.langflow.org/structured-output"
     name = "StructuredOutput"
     icon = "braces"
 

lfx/components/logic/__init__.py

@@ -1,5 +1,12 @@
+"""Logic module - backwards compatibility alias for flow_controls.
+
+This module provides backwards compatibility by forwarding imports
+to flow_controls where the actual logic components are located.
+"""
+
 from __future__ import annotations
 
+import sys
 from typing import TYPE_CHECKING, Any
 
 from lfx.components._importing import import_mod
@@ -36,12 +43,131 @@ __all__ = [
     "SubFlowComponent",
 ]
 
+# Register redirected submodules in sys.modules for direct importlib.import_module() calls
+# This allows imports like: import lfx.components.logic.listen
+_redirected_submodules = {
+    "lfx.components.logic.listen": "lfx.components.flow_controls.listen",
+    "lfx.components.logic.loop": "lfx.components.flow_controls.loop",
+    "lfx.components.logic.notify": "lfx.components.flow_controls.notify",
+    "lfx.components.logic.pass_message": "lfx.components.flow_controls.pass_message",
+    "lfx.components.logic.conditional_router": "lfx.components.flow_controls.conditional_router",
+    "lfx.components.logic.data_conditional_router": "lfx.components.flow_controls.data_conditional_router",
+    "lfx.components.logic.flow_tool": "lfx.components.flow_controls.flow_tool",
+    "lfx.components.logic.run_flow": "lfx.components.flow_controls.run_flow",
+    "lfx.components.logic.sub_flow": "lfx.components.flow_controls.sub_flow",
+}
+
+for old_path, new_path in _redirected_submodules.items():
+    if old_path not in sys.modules:
+        # Use a lazy loader that imports the actual module when accessed
+        class _RedirectedModule:
+            def __init__(self, target_path: str, original_path: str):
+                self._target_path = target_path
+                self._original_path = original_path
+                self._module = None
+
+            def __getattr__(self, name: str) -> Any:
+                if self._module is None:
+                    from importlib import import_module
+
+                    self._module = import_module(self._target_path)
+                    # Also register under the original path for future imports
+                    sys.modules[self._original_path] = self._module
+                return getattr(self._module, name)
+
+            def __repr__(self) -> str:
+                return f"<redirected module '{self._original_path}' -> '{self._target_path}'>"
+
+        sys.modules[old_path] = _RedirectedModule(new_path, old_path)
+
 
 def __getattr__(attr_name: str) -> Any:
     """Lazily import logic components on attribute access."""
+    # Handle submodule access for backwards compatibility
+    if attr_name == "listen":
+        from importlib import import_module
+
+        result = import_module("lfx.components.flow_controls.listen")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "loop":
+        from importlib import import_module
+
+        result = import_module("lfx.components.flow_controls.loop")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "notify":
+        from importlib import import_module
+
+        result = import_module("lfx.components.flow_controls.notify")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "pass_message":
+        from importlib import import_module
+
+        result = import_module("lfx.components.flow_controls.pass_message")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "conditional_router":
+        from importlib import import_module
+
+        result = import_module("lfx.components.flow_controls.conditional_router")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "data_conditional_router":
+        from importlib import import_module
+
+        result = import_module("lfx.components.flow_controls.data_conditional_router")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "flow_tool":
+        from importlib import import_module
+
+        result = import_module("lfx.components.flow_controls.flow_tool")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "run_flow":
+        from importlib import import_module
+
+        result = import_module("lfx.components.flow_controls.run_flow")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "sub_flow":
+        from importlib import import_module
+
+        result = import_module("lfx.components.flow_controls.sub_flow")
+        globals()[attr_name] = result
+        return result
+
     if attr_name not in _dynamic_imports:
         msg = f"module '{__name__}' has no attribute '{attr_name}'"
         raise AttributeError(msg)
+
+    # Most logic components were moved to flow_controls
+    # Forward them to flow_controls for backwards compatibility
+    if attr_name in (
+        "ConditionalRouterComponent",
+        "DataConditionalRouterComponent",
+        "FlowToolComponent",
+        "LoopComponent",
+        "PassMessageComponent",
+        "RunFlowComponent",
+        "SubFlowComponent",
+    ):
+        from lfx.components import flow_controls
+
+        result = getattr(flow_controls, attr_name)
+        globals()[attr_name] = result
+        return result
+
+    # SmartRouterComponent was moved to llm_operations
+    if attr_name == "SmartRouterComponent":
+        from lfx.components import llm_operations
+
+        result = getattr(llm_operations, attr_name)
+        globals()[attr_name] = result
+        return result
+
     try:
         result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
     except (ModuleNotFoundError, ImportError, AttributeError) as e:

lfx/components/mem0/mem0_chat_memory.py

@@ -7,6 +7,11 @@ from lfx.inputs.inputs import DictInput, HandleInput, MessageTextInput, NestedDi
 from lfx.io import Output
 from lfx.log.logger import logger
 from lfx.schema.data import Data
+from lfx.utils.validate_cloud import raise_error_if_astra_cloud_disable_component
+
+disable_component_in_astra_cloud_msg = (
+    "Mem0 chat memory is not supported in Astra cloud environment. Please use local storage mode or mem0 cloud."
+)
 
 
 class Mem0MemoryComponent(LCChatMemoryComponent):
@@ -80,6 +85,8 @@ class Mem0MemoryComponent(LCChatMemoryComponent):
 
     def build_mem0(self) -> Memory:
         """Initializes a Mem0 memory instance based on provided configuration and API keys."""
+        # Check if we're in Astra cloud environment and raise an error if we are.
+        raise_error_if_astra_cloud_disable_component(disable_component_in_astra_cloud_msg)
         if self.openai_api_key:
             os.environ["OPENAI_API_KEY"] = self.openai_api_key
 
@@ -95,6 +102,8 @@ class Mem0MemoryComponent(LCChatMemoryComponent):
 
     def ingest_data(self) -> Memory:
         """Ingests a new message into Mem0 memory and returns the updated memory instance."""
+        # Check if we're in Astra cloud environment and raise an error if we are.
+        raise_error_if_astra_cloud_disable_component(disable_component_in_astra_cloud_msg)
         mem0_memory = self.existing_memory or self.build_mem0()
 
         if not self.ingest_message or not self.user_id:
@@ -115,6 +124,8 @@ class Mem0MemoryComponent(LCChatMemoryComponent):
 
     def build_search_results(self) -> Data:
         """Searches the Mem0 memory for related messages based on the search query and returns the results."""
+        # Check if we're in Astra cloud environment and raise an error if we are.
+        raise_error_if_astra_cloud_disable_component(disable_component_in_astra_cloud_msg)
         mem0_memory = self.ingest_data()
         search_query = self.search_query
         user_id = self.user_id

lfx/components/models/__init__.py

@@ -1,28 +1,82 @@
+"""Models module - backwards compatibility alias for models_and_agents.
+
+This module provides backwards compatibility by forwarding model-related imports
+to models_and_agents where the actual model components are located.
+"""
+
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+import sys
+from typing import Any
 
 from lfx.components._importing import import_mod
 
-if TYPE_CHECKING:
-    from lfx.components.models.embedding_model import EmbeddingModelComponent
-    from lfx.components.models.language_model import LanguageModelComponent
-
+# Forward model components from models_and_agents
 _dynamic_imports = {
-    "EmbeddingModelComponent": "embedding_model",
     "LanguageModelComponent": "language_model",
+    "EmbeddingModelComponent": "embedding_model",
+}
+
+__all__ = [
+    "EmbeddingModelComponent",
+    "LanguageModelComponent",
+]
+
+# Register redirected submodules in sys.modules for direct importlib.import_module() calls
+# This allows imports like: import lfx.components.models.embedding_model
+_redirected_submodules = {
+    "lfx.components.models.embedding_model": "lfx.components.models_and_agents.embedding_model",
+    "lfx.components.models.language_model": "lfx.components.models_and_agents.language_model",
 }
 
-__all__ = ["EmbeddingModelComponent", "LanguageModelComponent"]
+for old_path, new_path in _redirected_submodules.items():
+    if old_path not in sys.modules:
+        # Use a lazy loader that imports the actual module when accessed
+        class _RedirectedModule:
+            def __init__(self, target_path: str, original_path: str):
+                self._target_path = target_path
+                self._original_path = original_path
+                self._module = None
+
+            def __getattr__(self, name: str) -> Any:
+                if self._module is None:
+                    from importlib import import_module
+
+                    self._module = import_module(self._target_path)
+                    # Also register under the original path for future imports
+                    sys.modules[self._original_path] = self._module
+                return getattr(self._module, name)
+
+            def __repr__(self) -> str:
+                return f"<redirected module '{self._original_path}' -> '{self._target_path}'>"
+
+        sys.modules[old_path] = _RedirectedModule(new_path, old_path)
 
 
 def __getattr__(attr_name: str) -> Any:
-    """Lazily import model components on attribute access."""
+    """Forward attribute access to models_and_agents components."""
+    # Handle submodule access for backwards compatibility
+    if attr_name == "embedding_model":
+        from importlib import import_module
+
+        result = import_module("lfx.components.models_and_agents.embedding_model")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "language_model":
+        from importlib import import_module
+
+        result = import_module("lfx.components.models_and_agents.language_model")
+        globals()[attr_name] = result
+        return result
+
     if attr_name not in _dynamic_imports:
         msg = f"module '{__name__}' has no attribute '{attr_name}'"
         raise AttributeError(msg)
+
+    # Import from models_and_agents using the correct package path
+    package = "lfx.components.models_and_agents"
     try:
-        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+        result = import_mod(attr_name, _dynamic_imports[attr_name], package)
     except (ModuleNotFoundError, ImportError, AttributeError) as e:
         msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
         raise AttributeError(msg) from e
@@ -31,4 +85,5 @@ def __getattr__(attr_name: str) -> Any:
 
 
 def __dir__() -> list[str]:
+    """Return directory of available components."""
     return list(__all__)