lfx-nightly 0.1.12.dev18__py3-none-any.whl → 0.1.12.dev20__py3-none-any.whl

lfx/components/agents/mcp_component.py

@@ -10,7 +10,7 @@ from lfx.base.agents.utils import maybe_unflatten_dict, safe_cache_get, safe_cac
 from lfx.base.mcp.util import MCPSseClient, MCPStdioClient, create_input_schema_from_json_schema, update_tools
 from lfx.custom.custom_component.component_with_cache import ComponentWithCache
 from lfx.inputs.inputs import InputTypes  # noqa: TC001
-from lfx.io import DropdownInput, McpInput, MessageTextInput, Output
+from lfx.io import BoolInput, DropdownInput, McpInput, MessageTextInput, Output
 from lfx.io.schema import flatten_schema, schema_to_langflow_inputs
 from lfx.log.logger import logger
 from lfx.schema.dataframe import DataFrame
@@ -53,6 +53,7 @@ class MCPToolsComponent(ComponentWithCache):
         "tool_placeholder",
         "mcp_server",
         "tool",
+        "use_cache",
     ]
 
     display_name = "MCP Tools"
@@ -68,6 +69,16 @@ class MCPToolsComponent(ComponentWithCache):
             info="Select the MCP Server that will be used by this component",
             real_time_refresh=True,
         ),
+        BoolInput(
+            name="use_cache",
+            display_name="Use Cached Server",
+            info=(
+                "Enable caching of MCP Server and tools to improve performance. "
+                "Disable to always fetch fresh tools and server updates."
+            ),
+            value=False,
+            advanced=True,
+        ),
         DropdownInput(
             name="tool",
             display_name="Tool",
@@ -132,16 +143,32 @@ class MCPToolsComponent(ComponentWithCache):
             self.tools = []
             return [], {"name": server_name, "config": server_config_from_value}
 
-        # Use shared cache if available
-        servers_cache = safe_cache_get(self._shared_component_cache, "servers", {})
-        cached = servers_cache.get(server_name) if isinstance(servers_cache, dict) else None
+        # Check if caching is enabled, default to False
+        use_cache = getattr(self, "use_cache", False)
+
+        # Use shared cache if available and caching is enabled
+        cached = None
+        if use_cache:
+            servers_cache = safe_cache_get(self._shared_component_cache, "servers", {})
+            cached = servers_cache.get(server_name) if isinstance(servers_cache, dict) else None
 
         if cached is not None:
-            self.tools = cached["tools"]
-            self.tool_names = cached["tool_names"]
-            self._tool_cache = cached["tool_cache"]
-            server_config_from_value = cached["config"]
-            return self.tools, {"name": server_name, "config": server_config_from_value}
+            try:
+                self.tools = cached["tools"]
+                self.tool_names = cached["tool_names"]
+                self._tool_cache = cached["tool_cache"]
+                server_config_from_value = cached["config"]
+            except (TypeError, KeyError, AttributeError) as e:
+                # Handle corrupted cache data by clearing it and continuing to fetch fresh tools
+                msg = f"Unable to use cached data for MCP Server{server_name}: {e}"
+                await logger.awarning(msg)
+                # Clear the corrupted cache entry
+                current_servers_cache = safe_cache_get(self._shared_component_cache, "servers", {})
+                if isinstance(current_servers_cache, dict) and server_name in current_servers_cache:
+                    current_servers_cache.pop(server_name)
+                    safe_cache_set(self._shared_component_cache, "servers", current_servers_cache)
+            else:
+                return self.tools, {"name": server_name, "config": server_config_from_value}
 
         try:
             try:
@@ -186,19 +213,21 @@ class MCPToolsComponent(ComponentWithCache):
             self.tool_names = [tool.name for tool in tool_list if hasattr(tool, "name")]
             self._tool_cache = tool_cache
             self.tools = tool_list
-            # Cache the result using shared cache
-            cache_data = {
-                "tools": tool_list,
-                "tool_names": self.tool_names,
-                "tool_cache": tool_cache,
-                "config": server_config,
-            }
-
-            # Safely update the servers cache
-            current_servers_cache = safe_cache_get(self._shared_component_cache, "servers", {})
-            if isinstance(current_servers_cache, dict):
-                current_servers_cache[server_name] = cache_data
-                safe_cache_set(self._shared_component_cache, "servers", current_servers_cache)
+
+            # Cache the result only if caching is enabled
+            if use_cache:
+                cache_data = {
+                    "tools": tool_list,
+                    "tool_names": self.tool_names,
+                    "tool_cache": tool_cache,
+                    "config": server_config,
+                }
+
+                # Safely update the servers cache
+                current_servers_cache = safe_cache_get(self._shared_component_cache, "servers", {})
+                if isinstance(current_servers_cache, dict):
+                    current_servers_cache[server_name] = cache_data
+                    safe_cache_set(self._shared_component_cache, "servers", current_servers_cache)
 
         except (TimeoutError, asyncio.TimeoutError) as e:
             msg = f"Timeout updating tool list: {e!s}"
@@ -294,14 +323,22 @@ class MCPToolsComponent(ComponentWithCache):
                 # Check if tools are already cached for this server before clearing
                 cached_tools = None
                 if current_server_name:
-                    servers_cache = safe_cache_get(self._shared_component_cache, "servers", {})
-                    if isinstance(servers_cache, dict):
-                        cached = servers_cache.get(current_server_name)
-                        if cached is not None:
-                            cached_tools = cached["tools"]
-                            self.tools = cached_tools
-                            self.tool_names = cached["tool_names"]
-                            self._tool_cache = cached["tool_cache"]
+                    use_cache = getattr(self, "use_cache", True)
+                    if use_cache:
+                        servers_cache = safe_cache_get(self._shared_component_cache, "servers", {})
+                        if isinstance(servers_cache, dict):
+                            cached = servers_cache.get(current_server_name)
+                            if cached is not None:
+                                try:
+                                    cached_tools = cached["tools"]
+                                    self.tools = cached_tools
+                                    self.tool_names = cached["tool_names"]
+                                    self._tool_cache = cached["tool_cache"]
+                                except (TypeError, KeyError, AttributeError) as e:
+                                    # Handle corrupted cache data by ignoring it
+                                    msg = f"Unable to use cached data for MCP Server,{current_server_name}: {e}"
+                                    await logger.awarning(msg)
+                                    cached_tools = None
 
                 # Only clear tools if we don't have cached tools for the current server
                 if not cached_tools:

lfx/components/data/mock_data.py

@@ -0,0 +1,401 @@
+import secrets
+from datetime import datetime, timedelta, timezone
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import Output
+from lfx.schema import Data, DataFrame
+from lfx.schema.message import Message
+
+
+class MockDataGeneratorComponent(Component):
+    """Mock Data Generator Component.
+
+    Generates sample data for testing and development purposes. Supports three main
+    Langflow output types: Message (text), Data (JSON), and DataFrame (tabular data).
+
+    This component is useful for:
+    - Testing workflows without real data sources
+    - Prototyping data processing pipelines
+    - Creating sample data for demonstrations
+    - Development and debugging of Langflow components
+    """
+
+    display_name = "Mock Data Generator"
+    description = (
+        "Generate sample data for testing and development. "
+        "Choose from text messages, JSON data, or tabular data formats."
+    )
+    icon = "database"
+    name = "MockDataGenerator"
+
+    inputs = []
+
+    outputs = [
+        Output(display_name="DataFrame Output", name="dataframe_output", method="generate_dataframe_output"),
+        Output(display_name="Message Output", name="message_output", method="generate_message_output"),
+        Output(display_name="Data Output", name="data_output", method="generate_data_output"),
+    ]
+
+    def build(self) -> DataFrame:
+        """Default build method - returns DataFrame when component is standalone."""
+        return self.generate_dataframe_output()
+
+    def generate_message_output(self) -> Message:
+        """Generate Message output specifically.
+
+        Returns:
+            Message: A Message object containing Lorem Ipsum text
+        """
+        try:
+            self.log("Generating Message mock data")
+            message = self._generate_message()
+            self.status = f"Generated Lorem Ipsum message ({len(message.text)} characters)"
+        except (ValueError, TypeError) as e:
+            error_msg = f"Error generating Message data: {e!s}"
+            self.log(error_msg)
+            self.status = f"Error: {error_msg}"
+            return Message(text=f"Error: {error_msg}")
+        else:
+            return message
+
+    def generate_data_output(self) -> Data:
+        """Generate Data output specifically.
+
+        Returns:
+            Data: A Data object containing sample JSON data (1 record)
+        """
+        try:
+            record_count = 1  # Fixed to 1 record for Data output
+            self.log(f"Generating Data mock data with {record_count} record")
+            data = self._generate_data(record_count)
+            self.status = f"Generated JSON data with {len(data.data.get('records', []))} record(s)"
+        except (ValueError, TypeError) as e:
+            error_msg = f"Error generating Data: {e!s}"
+            self.log(error_msg)
+            self.status = f"Error: {error_msg}"
+            return Data(data={"error": error_msg, "success": False})
+        else:
+            return data
+
+    def generate_dataframe_output(self) -> DataFrame:
+        """Generate DataFrame output specifically.
+
+        Returns:
+            DataFrame: A Langflow DataFrame with sample data (50 records)
+        """
+        try:
+            record_count = 50  # Fixed to 50 records for DataFrame output
+            self.log(f"Generating DataFrame mock data with {record_count} records")
+            return self._generate_dataframe(record_count)
+        except (ValueError, TypeError) as e:
+            error_msg = f"Error generating DataFrame: {e!s}"
+            self.log(error_msg)
+
+            try:
+                import pandas as pd
+
+                error_df = pd.DataFrame({"error": [error_msg]})
+                return DataFrame(error_df)
+            except ImportError:
+                # Even without pandas, return DataFrame wrapper
+                return DataFrame({"error": [error_msg]})
+
+    def _generate_message(self) -> Message:
+        """Generate a sample Message with Lorem Ipsum text.
+
+        Returns:
+            Message: A Message object containing Lorem Ipsum text
+        """
+        lorem_ipsum_texts = [
+            (
+                "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor "
+                "incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud "
+                "exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat."
+            ),
+            (
+                "Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla "
+                "pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt "
+                "mollit anim id est laborum."
+            ),
+            (
+                "Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, "
+                "totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto "
+                "beatae vitae dicta sunt explicabo."
+            ),
+            (
+                "Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, "
+                "sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt."
+            ),
+            (
+                "Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, "
+                "adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore "
+                "magnam aliquam quaerat voluptatem."
+            ),
+        ]
+
+        selected_text = secrets.choice(lorem_ipsum_texts)
+        return Message(text=selected_text)
+
+    def _generate_data(self, record_count: int) -> Data:
+        """Generate sample Data with JSON structure.
+
+        Args:
+            record_count: Number of records to generate
+
+        Returns:
+            Data: A Data object containing sample JSON data
+        """
+        # Sample data categories
+        companies = [
+            "TechCorp",
+            "DataSystems",
+            "CloudWorks",
+            "InnovateLab",
+            "DigitalFlow",
+            "SmartSolutions",
+            "FutureTech",
+            "NextGen",
+        ]
+        departments = ["Engineering", "Sales", "Marketing", "HR", "Finance", "Operations", "Support", "Research"]
+        statuses = ["active", "pending", "completed", "cancelled", "in_progress"]
+        categories = ["A", "B", "C", "D"]
+
+        # Generate sample records
+        records = []
+        base_date = datetime.now(tz=timezone.utc) - timedelta(days=365)
+
+        for i in range(record_count):
+            record = {
+                "id": f"REC-{1000 + i}",
+                "name": f"Sample Record {i + 1}",
+                "company": secrets.choice(companies),
+                "department": secrets.choice(departments),
+                "status": secrets.choice(statuses),
+                "category": secrets.choice(categories),
+                "value": round(secrets.randbelow(9901) + 100 + secrets.randbelow(100) / 100, 2),
+                "quantity": secrets.randbelow(100) + 1,
+                "rating": round(secrets.randbelow(41) / 10 + 1, 1),
+                "is_active": secrets.choice([True, False]),
+                "created_date": (base_date + timedelta(days=secrets.randbelow(366))).isoformat(),
+                "tags": [
+                    secrets.choice(
+                        [
+                            "important",
+                            "urgent",
+                            "review",
+                            "approved",
+                            "draft",
+                            "final",
+                        ]
+                    )
+                    for _ in range(secrets.randbelow(3) + 1)
+                ],
+            }
+            records.append(record)
+
+        # Create the main data structure
+        data_structure = {
+            "records": records,
+            "summary": {
+                "total_count": record_count,
+                "active_count": sum(1 for r in records if r["is_active"]),
+                "total_value": sum(r["value"] for r in records),
+                "average_rating": round(sum(r["rating"] for r in records) / record_count, 2),
+                "categories": list({r["category"] for r in records}),
+                "companies": list({r["company"] for r in records}),
+            },
+        }
+
+        return Data(data=data_structure)
+
+    def _generate_dataframe(self, record_count: int) -> DataFrame:
+        """Generate sample DataFrame with realistic business data.
+
+        Args:
+            record_count: Number of rows to generate
+
+        Returns:
+            DataFrame: A Langflow DataFrame with sample data
+        """
+        try:
+            import pandas as pd
+
+            self.log(f"pandas imported successfully, version: {pd.__version__}")
+        except ImportError as e:
+            self.log(f"pandas not available: {e!s}, creating simple DataFrame fallback")
+            # Create a simple DataFrame-like structure without pandas
+            data_result = self._generate_data(record_count)
+            # Convert Data to simple DataFrame format
+            try:
+                # Create a basic DataFrame structure from the Data
+                records = data_result.data.get("records", [])
+                if records:
+                    # Use first record to get column names
+                    columns = list(records[0].keys()) if records else ["error"]
+                    rows = [list(record.values()) for record in records]
+                else:
+                    columns = ["error"]
+                    rows = [["pandas not available"]]
+
+                # Create a simple dict-based DataFrame representation
+                simple_df_data = {
+                    col: [row[i] if i < len(row) else None for row in rows] for i, col in enumerate(columns)
+                }
+
+                # Return as DataFrame wrapper (Langflow will handle the display)
+                return DataFrame(simple_df_data)
+            except (ValueError, TypeError):
+                # Ultimate fallback - return the Data as DataFrame
+                return DataFrame({"data": [str(data_result.data)]})
+
+        try:
+            self.log(f"Starting DataFrame generation with {record_count} records")
+
+            # Sample data for realistic business dataset
+            first_names = [
+                "John",
+                "Jane",
+                "Michael",
+                "Sarah",
+                "David",
+                "Emily",
+                "Robert",
+                "Lisa",
+                "William",
+                "Jennifer",
+            ]
+            last_names = [
+                "Smith",
+                "Johnson",
+                "Williams",
+                "Brown",
+                "Jones",
+                "Garcia",
+                "Miller",
+                "Davis",
+                "Rodriguez",
+                "Martinez",
+            ]
+            cities = [
+                "New York",
+                "Los Angeles",
+                "Chicago",
+                "Houston",
+                "Phoenix",
+                "Philadelphia",
+                "San Antonio",
+                "San Diego",
+                "Dallas",
+                "San Jose",
+            ]
+            countries = ["USA", "Canada", "UK", "Germany", "France", "Australia", "Japan", "Brazil", "India", "Mexico"]
+            products = [
+                "Product A",
+                "Product B",
+                "Product C",
+                "Product D",
+                "Product E",
+                "Service X",
+                "Service Y",
+                "Service Z",
+            ]
+
+            # Generate DataFrame data
+            data = []
+            base_date = datetime.now(tz=timezone.utc) - timedelta(days=365)
+
+            self.log("Generating row data...")
+            for i in range(record_count):
+                row = {
+                    "customer_id": f"CUST-{10000 + i}",
+                    "first_name": secrets.choice(first_names),
+                    "last_name": secrets.choice(last_names),
+                    "email": f"user{i + 1}@example.com",
+                    "age": secrets.randbelow(63) + 18,
+                    "city": secrets.choice(cities),
+                    "country": secrets.choice(countries),
+                    "product": secrets.choice(products),
+                    "order_date": (base_date + timedelta(days=secrets.randbelow(366))).strftime("%Y-%m-%d"),
+                    "order_value": round(secrets.randbelow(991) + 10 + secrets.randbelow(100) / 100, 2),
+                    "quantity": secrets.randbelow(10) + 1,
+                    "discount": round(secrets.randbelow(31) / 100, 2),
+                    "is_premium": secrets.choice([True, False]),
+                    "satisfaction_score": secrets.randbelow(10) + 1,
+                    "last_contact": (base_date + timedelta(days=secrets.randbelow(366))).strftime("%Y-%m-%d"),
+                }
+                data.append(row)
+            # Create DataFrame
+            self.log("Creating pandas DataFrame...")
+            df = pd.DataFrame(data)
+            self.log(f"DataFrame created with shape: {df.shape}")
+
+            # Add calculated columns
+            self.log("Adding calculated columns...")
+            df["full_name"] = df["first_name"] + " " + df["last_name"]
+            df["discounted_value"] = df["order_value"] * (1 - df["discount"])
+            df["total_value"] = df["discounted_value"] * df["quantity"]
+
+            # Age group boundaries as constants
+            age_group_18_25 = 25
+            age_group_26_35 = 35
+            age_group_36_50 = 50
+            age_group_51_65 = 65
+
+            # Create age groups with better error handling
+            try:
+                df["age_group"] = pd.cut(
+                    df["age"],
+                    bins=[
+                        0,
+                        age_group_18_25,
+                        age_group_26_35,
+                        age_group_36_50,
+                        age_group_51_65,
+                        100,
+                    ],
+                    labels=[
+                        "18-25",
+                        "26-35",
+                        "36-50",
+                        "51-65",
+                        "65+",
+                    ],
+                )
+            except (ValueError, TypeError) as e:
+                self.log(f"Error creating age groups with pd.cut: {e!s}, using simple categorization")
+                df["age_group"] = df["age"].apply(
+                    lambda x: "18-25"
+                    if x <= age_group_18_25
+                    else "26-35"
+                    if x <= age_group_26_35
+                    else "36-50"
+                    if x <= age_group_36_50
+                    else "51-65"
+                    if x <= age_group_51_65
+                    else "65+"
+                )
+
+            self.log(f"Successfully generated DataFrame with shape: {df.shape}, columns: {list(df.columns)}")
+            # CRITICAL: Use DataFrame wrapper from Langflow
+            # DO NOT set self.status when returning DataFrames - it interferes with display
+            return DataFrame(df)
+
+        except (ValueError, TypeError) as e:
+            error_msg = f"Error generating DataFrame: {e!s}"
+            self.log(error_msg)
+            # DO NOT set self.status when returning DataFrames - it interferes with display
+            # Return a fallback DataFrame with error info using Langflow wrapper
+            try:
+                error_df = pd.DataFrame(
+                    {
+                        "error": [error_msg],
+                        "timestamp": [datetime.now(tz=timezone.utc).isoformat()],
+                        "attempted_records": [record_count],
+                    }
+                )
+                return DataFrame(error_df)
+            except (ValueError, TypeError) as fallback_error:
+                # Last resort: return simple error DataFrame
+                self.log(f"Fallback also failed: {fallback_error!s}")
+                simple_error_df = pd.DataFrame({"error": [error_msg]})
+                return DataFrame(simple_error_df)

{lfx_nightly-0.1.12.dev18.dist-info → lfx_nightly-0.1.12.dev20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lfx-nightly
-Version: 0.1.12.dev18
+Version: 0.1.12.dev20
 Summary: Langflow Executor - A lightweight CLI tool for executing and serving Langflow AI flows
 Author-email: Gabriel Luiz Freitas Almeida <gabriel@langflow.org>
 Requires-Python: <3.14,>=3.10

{lfx_nightly-0.1.12.dev18.dist-info → lfx_nightly-0.1.12.dev20.dist-info}/RECORD

@@ -111,7 +111,7 @@ lfx/components/agentql/__init__.py,sha256=Erl669Dzsk-SegsDPWTtkKbprMXVuv8UTCo5RE
 lfx/components/agentql/agentql_api.py,sha256=N94yEK7ZuQCIsFBlr_8dqrJY-K1-KNb6QEEYfDIsDME,5569
 lfx/components/agents/__init__.py,sha256=u1PH9Ui0dUgTdTZVP7cdVysCv4extdusKS_brcbE7Eg,1049
 lfx/components/agents/agent.py,sha256=1hsfPWkqCzRF4SKT7l9R1yaMor1J2MarXG1ISwDNVL0,26678
-lfx/components/agents/mcp_component.py,sha256=WEs3BLLEuNXqra0pQ4S42PLMoK1zTSGy6VCChvwzo8c,23486
+lfx/components/agents/mcp_component.py,sha256=dW0eENDKz8esIShOooDEL48r3J3GoI1h0tuqIPLSnR4,25462
 lfx/components/aiml/__init__.py,sha256=DNKB-HMFGFYmsdkON-s8557ttgBXVXADmS-BcuSQiIQ,1087
 lfx/components/aiml/aiml.py,sha256=23Ineg1ajlCoqXgWgp50I20OnQbaleRNsw1c6IzPu3A,3877
 lfx/components/aiml/aiml_embeddings.py,sha256=2uNwORuj55mxn2SfLbh7oAIfjuXwHbsnOqRjfMtQRqc,1095
@@ -207,6 +207,7 @@ lfx/components/data/csv_to_data.py,sha256=NsNe8rZdkqscnWPynbbd3-svrRj3EEWNaJszjW
 lfx/components/data/directory.py,sha256=iqINxxy5w60l753zraB-EDpYny8FR6vaa-AgVkdYsLk,3936
 lfx/components/data/file.py,sha256=mh1Jf0-RwvR5W9rhctlF63DiqNm-o1UICtg9EhQ4peo,26068
 lfx/components/data/json_to_data.py,sha256=p6MPyUgDvY9aKTL2_2cUGmkeK7baS-G9rkCvzHAnhw8,3571
+lfx/components/data/mock_data.py,sha256=9DAVvi_FfWhlATdWTdMCh95H4P6Mc4gGap0xM1UuQLU,16164
 lfx/components/data/news_search.py,sha256=m_Ez7ebKlx4Hg5jGjtM4kHwLltnCiqmxDMEDH6dHd4c,6181
 lfx/components/data/rss.py,sha256=RGUB2Iz07Du7p_GOm84W-i2uqDfG6DOc0IQdTKNQsjY,2487
 lfx/components/data/sql_executor.py,sha256=sN1lWM65O_pCfZxNAzgjtZmcTPGBLqMud2_7nFv-kpM,3726
@@ -717,7 +718,7 @@ lfx/utils/schemas.py,sha256=NbOtVQBrn4d0BAu-0H_eCTZI2CXkKZlRY37XCSmuJwc,3865
 lfx/utils/util.py,sha256=xGR32XDRr_TtruhjnXfI7lEWmk-vgywHAy3kz5SBowc,15725
 lfx/utils/util_strings.py,sha256=nU_IcdphNaj6bAPbjeL-c1cInQPfTBit8mp5Y57lwQk,1686
 lfx/utils/version.py,sha256=cHpbO0OJD2JQAvVaTH_6ibYeFbHJV0QDHs_YXXZ-bT8,671
-lfx_nightly-0.1.12.dev18.dist-info/METADATA,sha256=EtL8r6dXPXHTKyvRvzcxdvhc79NYttAJAlsTNmfxKsE,8068
-lfx_nightly-0.1.12.dev18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lfx_nightly-0.1.12.dev18.dist-info/entry_points.txt,sha256=1724p3RHDQRT2CKx_QRzEIa7sFuSVO0Ux70YfXfoMT4,42
-lfx_nightly-0.1.12.dev18.dist-info/RECORD,,
+lfx_nightly-0.1.12.dev20.dist-info/METADATA,sha256=1G7VkJlIS_1PAK-i2DkYu4z3jhtprq4nZzwGNGbQ0ag,8068
+lfx_nightly-0.1.12.dev20.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lfx_nightly-0.1.12.dev20.dist-info/entry_points.txt,sha256=1724p3RHDQRT2CKx_QRzEIa7sFuSVO0Ux70YfXfoMT4,42
+lfx_nightly-0.1.12.dev20.dist-info/RECORD,,