memra 0.2.13__py3-none-any.whl → 0.2.15__py3-none-any.whl

memra/cli.py

@@ -37,11 +37,18 @@ def run_demo():
     print("⏳ Waiting for services to be ready...")
     wait_for_services()
     
-    # Step 5: Run the demo
+    # Step 5: Start MCP bridge server
+    print("🔌 Starting MCP bridge server...")
+    if not start_mcp_bridge_server(demo_dir):
+        print("❌ Failed to start MCP bridge server.")
+        print("   You can start it manually: cd memra-ops && python mcp_bridge_server.py")
+        return False
+    
+    # Step 6: Run the demo
     print("🎯 Running ETL workflow...")
     success = run_etl_workflow(demo_dir)
     
-    # Step 6: Show results
+    # Step 7: Show results
     if success:
         print("=" * 50)
         print("🎉 Demo completed successfully!")
@@ -53,6 +60,7 @@ def run_demo():
         print("  • Check database: docker exec -it memra_postgres psql -U postgres -d local_workflow")
         print("  • View data: SELECT * FROM invoices ORDER BY created_at DESC;")
         print("  • Stop services: cd memra-ops && docker compose down")
+        print("  • Stop MCP server: pkill -f mcp_bridge_server.py")
         print("  • Explore code: Check the extracted files in the demo directory")
     else:
         print("❌ Demo failed. Check the logs above for details.")
@@ -158,36 +166,132 @@ import asyncio
 import aiohttp
 from aiohttp import web
 import json
+import psycopg2
+import os
 
-async def health_handler(request):
-    return web.json_response({"status": "healthy"})
+class MCPBridgeServer:
+    def __init__(self):
+        self.db_url = os.getenv('DATABASE_URL', 'postgresql://postgres:postgres@localhost:5432/local_workflow')
+    
+    async def health_handler(self, request):
+        return web.json_response({"status": "healthy", "server": "MCP Bridge"})
+    
+    async def execute_tool_handler(self, request):
+        try:
+            data = await request.json()
+            tool_name = data.get('tool_name', 'unknown')
+            tool_params = data.get('parameters', {})
+            
+            if tool_name == 'SQLExecutor':
+                return await self.execute_sql(tool_params)
+            elif tool_name == 'PostgresInsert':
+                return await self.insert_data(tool_params)
+            elif tool_name == 'DataValidator':
+                return await self.validate_data(tool_params)
+            else:
+                return web.json_response({
+                    "success": True,
+                    "message": f"Demo {tool_name} executed",
+                    "data": {"demo": True}
+                })
+        except Exception as e:
+            return web.json_response({
+                "success": False,
+                "error": str(e)
+            }, status=500)
+    
+    async def execute_sql(self, params):
+        try:
+            query = params.get('query', 'SELECT 1')
+            conn = psycopg2.connect(self.db_url)
+            cursor = conn.cursor()
+            cursor.execute(query)
+            results = cursor.fetchall()
+            cursor.close()
+            conn.close()
+            
+            return web.json_response({
+                "success": True,
+                "results": results,
+                "query": query
+            })
+        except Exception as e:
+            return web.json_response({
+                "success": False,
+                "error": f"SQL execution failed: {str(e)}"
+            }, status=500)
+    
+    async def insert_data(self, params):
+        try:
+            table_name = params.get('table_name', 'invoices')
+            data = params.get('data', {})
+            
+            conn = psycopg2.connect(self.db_url)
+            cursor = conn.cursor()
+            
+            # Simple insert logic
+            columns = list(data.keys())
+            values = list(data.values())
+            placeholders = ', '.join(['%s'] * len(values))
+            column_list = ', '.join(columns)
+            
+            query = f"INSERT INTO {table_name} ({column_list}) VALUES ({placeholders}) RETURNING id"
+            cursor.execute(query, values)
+            record_id = cursor.fetchone()[0]
+            
+            conn.commit()
+            cursor.close()
+            conn.close()
+            
+            return web.json_response({
+                "success": True,
+                "record_id": record_id,
+                "message": f"Inserted into {table_name}"
+            })
+        except Exception as e:
+            return web.json_response({
+                "success": False,
+                "error": f"Insert failed: {str(e)}"
+            }, status=500)
+    
+    async def validate_data(self, params):
+        try:
+            data = params.get('data', {})
+            
+            # Simple validation
+            is_valid = True
+            errors = []
+            
+            if not data.get('vendor_name'):
+                is_valid = False
+                errors.append("Missing vendor name")
+            
+            if not data.get('amount') or float(data.get('amount', 0)) <= 0:
+                is_valid = False
+                errors.append("Invalid amount")
+            
+            return web.json_response({
+                "success": True,
+                "is_valid": is_valid,
+                "errors": errors,
+                "validated_data": data
+            })
+        except Exception as e:
+            return web.json_response({
+                "success": False,
+                "error": f"Validation failed: {str(e)}"
+            }, status=500)
 
-async def execute_tool_handler(request):
-    data = await request.json()
-    tool_name = data.get('tool_name', 'unknown')
-    
-    # Mock responses for demo
-    if tool_name == 'SQLExecutor':
-        return web.json_response({
-            "success": True,
-            "results": [{"message": "Demo SQL executed"}]
-        })
-    elif tool_name == 'PostgresInsert':
-        return web.json_response({
-            "success": True,
-            "id": 1
-        })
-    else:
-        return web.json_response({
-            "success": True,
-            "message": f"Demo {tool_name} executed"
-        })
+# Create server instance
+server = MCPBridgeServer()
 
+# Create web application
 app = web.Application()
-app.router.add_get('/health', health_handler)
-app.router.add_post('/execute_tool', execute_tool_handler)
+app.router.add_get('/health', server.health_handler)
+app.router.add_post('/execute_tool', server.execute_tool_handler)
 
 if __name__ == '__main__':
+    print("🚀 Starting MCP Bridge Server on port 8081...")
     web.run_app(app, host='0.0.0.0', port=8081)
 """
         
@@ -232,36 +336,132 @@ import asyncio
 import aiohttp
 from aiohttp import web
 import json
+import psycopg2
+import os
 
-async def health_handler(request):
-    return web.json_response({"status": "healthy"})
+class MCPBridgeServer:
+    def __init__(self):
+        self.db_url = os.getenv('DATABASE_URL', 'postgresql://postgres:postgres@localhost:5432/local_workflow')
+    
+    async def health_handler(self, request):
+        return web.json_response({"status": "healthy", "server": "MCP Bridge"})
+    
+    async def execute_tool_handler(self, request):
+        try:
+            data = await request.json()
+            tool_name = data.get('tool_name', 'unknown')
+            tool_params = data.get('parameters', {})
+            
+            if tool_name == 'SQLExecutor':
+                return await self.execute_sql(tool_params)
+            elif tool_name == 'PostgresInsert':
+                return await self.insert_data(tool_params)
+            elif tool_name == 'DataValidator':
+                return await self.validate_data(tool_params)
+            else:
+                return web.json_response({
+                    "success": True,
+                    "message": f"Demo {tool_name} executed",
+                    "data": {"demo": True}
+                })
+        except Exception as e:
+            return web.json_response({
+                "success": False,
+                "error": str(e)
+            }, status=500)
+    
+    async def execute_sql(self, params):
+        try:
+            query = params.get('query', 'SELECT 1')
+            conn = psycopg2.connect(self.db_url)
+            cursor = conn.cursor()
+            cursor.execute(query)
+            results = cursor.fetchall()
+            cursor.close()
+            conn.close()
+            
+            return web.json_response({
+                "success": True,
+                "results": results,
+                "query": query
+            })
+        except Exception as e:
+            return web.json_response({
+                "success": False,
+                "error": f"SQL execution failed: {str(e)}"
+            }, status=500)
+    
+    async def insert_data(self, params):
+        try:
+            table_name = params.get('table_name', 'invoices')
+            data = params.get('data', {})
+            
+            conn = psycopg2.connect(self.db_url)
+            cursor = conn.cursor()
+            
+            # Simple insert logic
+            columns = list(data.keys())
+            values = list(data.values())
+            placeholders = ', '.join(['%s'] * len(values))
+            column_list = ', '.join(columns)
+            
+            query = f"INSERT INTO {table_name} ({column_list}) VALUES ({placeholders}) RETURNING id"
+            cursor.execute(query, values)
+            record_id = cursor.fetchone()[0]
+            
+            conn.commit()
+            cursor.close()
+            conn.close()
+            
+            return web.json_response({
+                "success": True,
+                "record_id": record_id,
+                "message": f"Inserted into {table_name}"
+            })
+        except Exception as e:
+            return web.json_response({
+                "success": False,
+                "error": f"Insert failed: {str(e)}"
+            }, status=500)
+    
+    async def validate_data(self, params):
+        try:
+            data = params.get('data', {})
+            
+            # Simple validation
+            is_valid = True
+            errors = []
+            
+            if not data.get('vendor_name'):
+                is_valid = False
+                errors.append("Missing vendor name")
+            
+            if not data.get('amount') or float(data.get('amount', 0)) <= 0:
+                is_valid = False
+                errors.append("Invalid amount")
+            
+            return web.json_response({
+                "success": True,
+                "is_valid": is_valid,
+                "errors": errors,
+                "validated_data": data
+            })
+        except Exception as e:
+            return web.json_response({
+                "success": False,
+                "error": f"Validation failed: {str(e)}"
+            }, status=500)
 
-async def execute_tool_handler(request):
-    data = await request.json()
-    tool_name = data.get('tool_name', 'unknown')
-    
-    # Mock responses for demo
-    if tool_name == 'SQLExecutor':
-        return web.json_response({
-            "success": True,
-            "results": [{"message": "Demo SQL executed"}]
-        })
-    elif tool_name == 'PostgresInsert':
-        return web.json_response({
-            "success": True,
-            "id": 1
-        })
-    else:
-        return web.json_response({
-            "success": True,
-            "message": f"Demo {tool_name} executed"
-        })
+# Create server instance
+server = MCPBridgeServer()
 
+# Create web application
 app = web.Application()
-app.router.add_get('/health', health_handler)
-app.router.add_post('/execute_tool', execute_tool_handler)
+app.router.add_get('/health', server.health_handler)
+app.router.add_post('/execute_tool', server.execute_tool_handler)
 
 if __name__ == '__main__':
+    print("🚀 Starting MCP Bridge Server on port 8081...")
     web.run_app(app, host='0.0.0.0', port=8081)
 """
     
@@ -498,8 +698,32 @@ def run_etl_workflow(demo_dir):
         real_demo_script = demo_dir / "etl_invoice_demo.py"
         if real_demo_script.exists():
             print("🎯 Running real ETL workflow...")
+            print(f"📁 Working directory: {demo_dir}")
+            print(f"📄 Demo script: {real_demo_script}")
+            
+            # Check if data directory exists
+            data_dir = demo_dir / "data"
+            invoices_dir = data_dir / "invoices"
+            if invoices_dir.exists():
+                pdf_files = list(invoices_dir.glob("*.PDF"))
+                print(f"📊 Found {len(pdf_files)} PDF files in {invoices_dir}")
+                if pdf_files:
+                    print(f"   First few files: {[f.name for f in pdf_files[:3]]}")
+            else:
+                print(f"⚠️  Warning: {invoices_dir} does not exist")
+                print(f"   Available directories in {demo_dir}:")
+                for item in demo_dir.iterdir():
+                    if item.is_dir():
+                        print(f"     - {item.name}/")
+            
             print("⏱️  Processing 15 files with delays - this may take 10-15 minutes")
-            result = subprocess.run([sys.executable, str(real_demo_script)], cwd=demo_dir, timeout=1800)  # 30 minute timeout
+            
+            # Set the working directory to the demo directory so the script can find data/invoices/
+            result = subprocess.run(
+                [sys.executable, str(real_demo_script)], 
+                cwd=demo_dir,  # This is crucial - sets working directory
+                timeout=1800   # 30 minute timeout
+            )
             return result.returncode == 0
         else:
             # Fallback to simplified demo
@@ -510,6 +734,10 @@ def run_etl_workflow(demo_dir):
                 return result.returncode == 0
             else:
                 print("❌ No demo script found")
+                print(f"   Looking for: {real_demo_script}")
+                print(f"   Available files in {demo_dir}:")
+                for item in demo_dir.iterdir():
+                    print(f"     - {item.name}")
                 return False
             
     except subprocess.TimeoutExpired:
@@ -520,6 +748,49 @@ def run_etl_workflow(demo_dir):
         print(f"❌ Error running ETL workflow: {e}")
         return False
 
+def start_mcp_bridge_server(demo_dir):
+    """Start the MCP bridge server"""
+    try:
+        ops_dir = demo_dir / "memra-ops"
+        bridge_script = ops_dir / "mcp_bridge_server.py"
+        
+        if not bridge_script.exists():
+            print("❌ MCP bridge server script not found")
+            return False
+        
+        # Start the bridge server in the background
+        if os.name == 'nt':  # Windows
+            # Use start command to run in background
+            result = subprocess.run([
+                'start', '/B', 'python', str(bridge_script)
+            ], cwd=ops_dir, shell=True, capture_output=True, text=True)
+        else:  # Unix/Linux/Mac
+            result = subprocess.run([
+                'python', str(bridge_script)
+            ], cwd=ops_dir, start_new_session=True, capture_output=True, text=True)
+        
+        # Wait a moment for the server to start
+        time.sleep(3)
+        
+        # Check if the server is responding
+        try:
+            import requests
+            response = requests.get('http://localhost:8081/health', timeout=5)
+            if response.status_code == 200:
+                print("✅ MCP bridge server started successfully")
+                return True
+            else:
+                print(f"⚠️  MCP bridge server responded with status {response.status_code}")
+                return False
+        except Exception as e:
+            print(f"⚠️  Could not verify MCP bridge server: {e}")
+            print("   Server may still be starting up...")
+            return True  # Assume it's working
+            
+    except Exception as e:
+        print(f"❌ Error starting MCP bridge server: {e}")
+        return False
+
 def main():
     """Main CLI entry point"""
     if len(sys.argv) < 2:

{memra-0.2.13.dist-info → memra-0.2.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: memra
-Version: 0.2.13
+Version: 0.2.15
 Summary: Declarative framework for enterprise workflows with MCP integration - Client SDK
 Home-page: https://github.com/memra/memra-sdk
 Author: Memra

{memra-0.2.13.dist-info → memra-0.2.15.dist-info}/RECORD

@@ -1,5 +1,5 @@
 memra/__init__.py,sha256=6i82jodsWZPgtRhUaDF3wuQuRDSaboIpew8D3zDN__s,1109
-memra/cli.py,sha256=wFmGDUJBgWhQJ5NG99TXDuk4laezivZbSWEbiobcYhs,19105
+memra/cli.py,sha256=_IlOrTBlv_zBElxxQs13JYsdAuOn9wO1UiogmnwO1Qg,29430
 memra/discovery.py,sha256=yJIQnrDQu1nyzKykCIuzG_5SW5dIXHCEBLLKRWacIoY,480
 memra/discovery_client.py,sha256=AbnKn6qhyrf7vmOvknEeDzH4tiGHsqPHtDaein_qaW0,1271
 memra/execution.py,sha256=OXpBKxwBIjhACWL_qh8KHNndO8HUgB6gBF81AiQBBm0,34751
@@ -58,63 +58,9 @@ memra/demos/etl_invoice_processing/data/invoices/10352262702.PDF,sha256=aNWnxbYq
 memra/demos/etl_invoice_processing/data/invoices/10352262884.PDF,sha256=G0eszEhpTOS15hIlMyPMM6iyVw6UZPKycXvS3P42xRc,1010830
 memra/demos/etl_invoice_processing/data/invoices/10352263346.PDF,sha256=NMfsgrmaNtvNu6xk2aLtubI05I9cuVIbwJMxv_pYPhQ,1089624
 memra/demos/etl_invoice_processing/data/invoices/10352263429.PDF,sha256=1IzJbmnsKDE1cV6CtyNMENn0Rmpq2tA_BDnZYTYhNhQ,1082893
-memra-ops/app.py,sha256=S8B82gOAuT9x-NhmVLL9HM03Pde3Fa7QXm6TG1PEbbU,29439
-memra-ops/config.py,sha256=6mBbS_stoEIhJDBqdJOalryAnyWeHbDy81mU1j08ids,969
-memra-ops/mcp_bridge_server.py,sha256=tDEigRstIEAEu16F1ctCor2ny9CBbEOMY046bHdzFpE,47607
-memra-ops/server_tool_registry.py,sha256=rg5wz8dTfJNqo2QRe69iBKJKeoJemltt_XzZsdxyJa8,8367
-memra-ops/config/config.py,sha256=7dcT9W5b_nWrVAylbdeOaA60_NJlhv2YLyEILTcNKtI,600
-memra-ops/logic/__init__.py,sha256=UFKwzAUU-5pWt-7gcajY1M9PLoJ1wiQ8L0HDTlkRv7E,43
-memra-ops/logic/file_tools.py,sha256=iVe4xE7lNBhhoiL0Hi2zx4oF7koDeVvsOh1uMbn6HEo,1126
-memra-ops/logic/invoice_tools.py,sha256=Jp3PEFfUXRTAAP1ZM4Juei_zzPKy8EFi8H2uP6T9c2A,27787
-memra-ops/logic/invoice_tools_fix.py,sha256=sF4qADqbfWEgOyavslrNlCDEyIkaZo35TtnyHd7PClY,3020
-memra-ops/scripts/check_database.py,sha256=sBPmIJ10WW3jHQfOjeDRJnQahRBwVAi60-98r4HG9rw,987
-memra-ops/scripts/clear_database.py,sha256=yO4JUbMOcSQ1-S57n1oua-SheM360yg-oNiPyj8LW5o,1441
-memra-ops/scripts/monitor_database.py,sha256=OmIgUmtVjtUfSziSEiTy5CheueMMZ5R5HciPpMishE0,2287
-memra-ops/scripts/release.py,sha256=riQ-jz7-vnd1cSfQdU1eUZmVDyuWym1nmZW65lGetiI,4218
-memra-ops/scripts/reset_database.py,sha256=QJagPQIkMOr3s-o-g_Urz0CvSYNm0D2xbwo3JSrKIWY,2255
-memra-ops/scripts/start_memra.py,sha256=VR7WESQXgvPuzZEFMhtmABSR7IzYixsnpgtoPcECLK0,11987
-memra-ops/scripts/stop_memra.py,sha256=yyTu4jxjUbxTrvobQ-UhpNk-eWB8bCFjcBPGW1scIJg,4591
-memra-ops/tests/test_llm_text_to_sql.py,sha256=IDL7FEzlm2Dr9pRCcJQ6SGddF9VBDfHonwztrDpxBGU,4099
-memra-ops/tests/test_llm_vs_pattern.py,sha256=ZATV1fS7C6Jn-N4-UB5LzuRjbiO1ctZq3gNoIud2RWc,4880
-memra-ops/tests/test_mcp_schema_aware.py,sha256=H5NmGxS3LWo9xoodqVeliJyHco7ZjGOtHg80ep1SHzw,4537
-memra-ops/tests/test_schema_aware_sql.py,sha256=b_XPtv7eldR2ARBVlriTHMA1nwqYUcMgthL8mHpewuM,4645
-memra-ops/tests/test_schema_aware_sql_simple.py,sha256=8f8zijkTwvIqVHM3B5oVviRfFS-U6bfC43fk9hcWsoE,2309
-memra-ops/tests/test_text_to_sql_demo.py,sha256=5mmpSwXZ8r8sj3J9iCYkFx0SgwyXPe-7Prie1hL6cis,5092
-memra-ops/tools/mcp_bridge_server.py,sha256=IKUNusZovPdR0_6Bv_XejmAk27lnHrM1uOE8xPVnM8s,35051
-memra-sdk/setup.py,sha256=j95Pq2ha28B3owPv0J1isq5pgUwa9p02nbBXqxa4Lwo,1513
-memra-sdk/examples/accounts_payable.py,sha256=PfpXKrGOUu6NpkNcHy6cN6TtsXfnsJZhUv-KGlOvDqY,7990
-memra-sdk/examples/accounts_payable_client.py,sha256=tLHHCydEpasLHTHd4YULhSxFy6zs81X5PZHav0dlQ2I,7816
-memra-sdk/examples/accounts_payable_mcp.py,sha256=lOgwDfMVKxifQi70GmeXQnpZiIFrZnNj5_JSZ9qsdBw,7344
-memra-sdk/examples/ask_questions.py,sha256=jek7EVXXZ_vODlMy_hQGQCkN9vYBfaW7SOWsIQRV2GY,3830
-memra-sdk/examples/invoice_processing.py,sha256=STe3ri65WH_Ss84qiRWuGZTpDZke5GoJf8LEqOAc5ys,3980
-memra-sdk/examples/propane_delivery.py,sha256=ryvIxDjM9GJY9T6fFIqJgHOcX2PEMkfF_t_3E5CyZW4,2539
-memra-sdk/examples/simple_text_to_sql.py,sha256=NnpKo9nFpmPQ089zcSx4wwG6_tSHTmGJSS7LPs55NA0,5314
-memra-sdk/memra/__init__.py,sha256=CTiSeBBZ40-pNd2-wBIdZduqNLrA5OnWmmwk1y1f894,787
-memra-sdk/memra/discovery.py,sha256=yJIQnrDQu1nyzKykCIuzG_5SW5dIXHCEBLLKRWacIoY,480
-memra-sdk/memra/discovery_client.py,sha256=AbnKn6qhyrf7vmOvknEeDzH4tiGHsqPHtDaein_qaW0,1271
-memra-sdk/memra/execution.py,sha256=P7tAur0SEMtX6uLlfxTfCZBgMLIRj6Wl3dsv2EA9fHc,23443
-memra-sdk/memra/models.py,sha256=sXMPRnMB_mUVtJdBFyd0ElCf_uh1yqx7iLssIYNm0vI,3333
-memra-sdk/memra/tool_registry.py,sha256=P2TafpiqV19yzi0jVrQQrXFGBpQkbmePbRfEW_ai24M,14700
-memra-sdk/memra/tool_registry_client.py,sha256=uzMQ4COvRams9vuPLcqcdljUpDlAYU_tyFxrRhrA0Lc,4009
-memra-sdk/scripts/release.py,sha256=riQ-jz7-vnd1cSfQdU1eUZmVDyuWym1nmZW65lGetiI,4218
-memra-workflows/mcp_bridge_server.py,sha256=6K9fedZiwNpkT7wGAS6IW-HgMYBUC94zu8ppUgftqDg,8528
-memra-workflows/accounts_payable/accounts_payable.py,sha256=rRpviqKZ-g0KPEnI98GbXy-KnyTrN1dLkj0HP9PKlYs,8012
-memra-workflows/accounts_payable/accounts_payable_client.py,sha256=kNu2EQ8d6T6qcKn68FznnMGBeoqtXFbN4PHDVDImapk,7813
-memra-workflows/accounts_payable/accounts_payable_mcp.py,sha256=kySt7PKyIgLbG1Q3jPY1kFPQK8o_3aAmL9vJG2Qcnxc,7366
-memra-workflows/accounts_payable/accounts_payable_smart.py,sha256=g_V6-1qPsLiIOFw-eLT4w-RoljjErF65SuKRzkEeSck,8004
-memra-workflows/invoice_processing/invoice_processing.py,sha256=STe3ri65WH_Ss84qiRWuGZTpDZke5GoJf8LEqOAc5ys,3980
-memra-workflows/invoice_processing/smart_invoice_processor.py,sha256=Ct3ZjNujK4VTlCDgwMWXn6Y7b1dg0a_eIbRP-xm-p3g,7203
-memra-workflows/logic/__init__.py,sha256=kLTdniFpBqOusmRng8W2LSIAmgj-jfM3Agjl_vXYTl8,76
-memra-workflows/logic/file_tools.py,sha256=n6uDwInPZcr74zAJJbA9iZajWgRcKoHYtEKX_lbzsik,1586
-memra-workflows/logic/invoice_tools.py,sha256=wLTI0JqkMYMlFv1z_DPwliIvKbpFBcYh5SnEnhU13Co,20366
-memra-workflows/logic/propane_agents.py,sha256=ZF1RSccn73a5XZVa-1nxgjvubcYzf62g9lr9PoTbGl4,1804
-memra-workflows/propane_delivery/propane_delivery.py,sha256=ryvIxDjM9GJY9T6fFIqJgHOcX2PEMkfF_t_3E5CyZW4,2539
-memra-workflows/text_to_sql/complete_invoice_workflow_with_queries.py,sha256=x4wq3o_ogFnnrI6MQwEhqIiNH-NNwS5SXQUoKd_br7U,7428
-memra-workflows/text_to_sql/complete_text_to_sql_system.py,sha256=Izj4ucXDXTWFY29SWr2YrEf3ZyXH4QCDEljNk4jlpI0,8991
-memra-workflows/text_to_sql/file_discovery_demo.py,sha256=4R_QN0Y6OtHmnX6CvtwDXen122XCDrk-MRBOzxb_x_k,5306
-memra-0.2.13.dist-info/LICENSE,sha256=8OrnTd8DWwLWmUEj5srSLvT4PREfW1Qo1T5gEUIHPws,1062
-memra-0.2.13.dist-info/METADATA,sha256=KwY4StFLr17bUJ6eZ3eazCqwBZlVX7jBMzX_bB9iKxY,9427
-memra-0.2.13.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-memra-0.2.13.dist-info/entry_points.txt,sha256=LBVjwWoxWJRzNLgeByPn6xUvWFIRnqnemvAZgIoSt08,41
-memra-0.2.13.dist-info/top_level.txt,sha256=IviXF9qSQY_BidRYund9zFaV-q1VMl6CuizwTAggQks,42
-memra-0.2.13.dist-info/RECORD,,
+memra-0.2.15.dist-info/LICENSE,sha256=8OrnTd8DWwLWmUEj5srSLvT4PREfW1Qo1T5gEUIHPws,1062
+memra-0.2.15.dist-info/METADATA,sha256=-a6F6PGuriDeFNJjtGn30f0XFdt64O1pmkZjKwvzCB8,9427
+memra-0.2.15.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+memra-0.2.15.dist-info/entry_points.txt,sha256=LBVjwWoxWJRzNLgeByPn6xUvWFIRnqnemvAZgIoSt08,41
+memra-0.2.15.dist-info/top_level.txt,sha256=pXWcTRS1zctdiSUivW4iyKpJ4tcfIu-1BW_fpbal3OY,6
+memra-0.2.15.dist-info/RECORD,,

memra-0.2.15.dist-info/top_level.txt

@@ -0,0 +1 @@
+memra

memra-0.2.13.dist-info/top_level.txt

@@ -1,4 +0,0 @@
-memra
-memra-ops
-memra-sdk
-memra-workflows