@motiadev/core 0.4.2-beta.94 → 0.4.3-beta.96

package/dist/src/locked-data.js

@@ -8,8 +8,9 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const guards_1 = require("./guards");
 const step_validator_1 = require("./step-validator");
+const file_stream_adapter_1 = require("./streams/adapters/file-stream-adapter");
+const memory_stream_adapter_1 = require("./streams/adapters/memory-stream-adapter");
 const generate_types_1 = require("./types/generate-types");
-const trace_stream_adapter_1 = require("./observability/trace-stream-adapter");
 class LockedData {
     constructor(baseDir, streamAdapter = 'file', printer) {
         this.baseDir = baseDir;
@@ -264,7 +265,10 @@ class LockedData {
         return validationResult.success;
     }
     createStreamAdapter(streamName) {
-        return new trace_stream_adapter_1.TraceStreamAdapter(this.baseDir, streamName, this.streamAdapter);
+        if (this.streamAdapter === 'file') {
+            return new file_stream_adapter_1.FileStreamAdapter(this.baseDir, streamName);
+        }
+        return new memory_stream_adapter_1.MemoryStreamAdapter();
     }
 }
 exports.LockedData = LockedData;

package/dist/src/python/{communication_factory.py → motia_communication_factory.py}

@@ -1,8 +1,8 @@
 import os
 import platform
 from typing import Union
-from rpc_communication import RpcCommunication
-from ipc_communication import IpcCommunication
+from motia_rpc_communication import RpcCommunication
+from motia_ipc_communication import IpcCommunication
 
 def create_communication() -> Union[RpcCommunication, IpcCommunication]:
     """

package/dist/src/python/{context.py → motia_context.py}

@@ -1,9 +1,9 @@
 from typing import Any, List, Optional
-from type_definitions import HandlerResult
-from rpc import RpcSender
-from rpc_state_manager import RpcStateManager
-from logger import Logger
-from dot_dict import DotDict
+from motia_type_definitions import HandlerResult
+from motia_rpc import RpcSender
+from motia_rpc_state_manager import RpcStateManager
+from motia_logger import Logger
+from motia_dot_dict import DotDict
 
 class Context:
     def __init__(

package/dist/src/python/{logger.py → motia_logger.py}

@@ -1,6 +1,6 @@
 import time
 from typing import Any, Dict, Optional
-from rpc import RpcSender
+from motia_rpc import RpcSender
 
 class Logger:
     def __init__(self, trace_id: str, flows: list[str], rpc: RpcSender):

package/dist/src/python/{middleware.py → motia_middleware.py}

@@ -1,6 +1,6 @@
 from typing import Any, Callable
 from functools import reduce
-from context import Context
+from motia_context import Context
 
 def compose_middleware(*middlewares):
     """Compose multiple middleware functions into a single middleware"""

package/dist/src/python/{rpc.py → motia_rpc.py}

@@ -1,13 +1,7 @@
-import uuid
-import asyncio
-import json
-import sys
-import os
-import platform
-from typing import Any, Dict, Optional, Callable, Union
-from communication_factory import create_communication
-from rpc_communication import RpcCommunication
-from ipc_communication import IpcCommunication
+from typing import Any, Union
+from motia_communication_factory import create_communication
+from motia_rpc_communication import RpcCommunication
+from motia_ipc_communication import IpcCommunication
 
 def serialize_for_json(obj: Any) -> Any:
     """Convert Python objects to JSON-serializable types"""

package/dist/src/python/{rpc_state_manager.py → motia_rpc_state_manager.py}

@@ -1,8 +1,8 @@
-from typing import Any
 import asyncio
-from rpc import RpcSender
 import functools
 import sys
+from typing import Any
+from motia_rpc import RpcSender
 
 class RpcStateManager:
     def __init__(self, rpc: RpcSender):

package/dist/src/python/{rpc_stream_manager.py → motia_rpc_stream_manager.py}

@@ -1,8 +1,8 @@
-from typing import Any
 import asyncio
-from rpc import RpcSender
 import functools
 import sys
+from typing import Any
+from motia_rpc import RpcSender
 
 class RpcStreamManager:
     def __init__(self, stream_name: str,rpc: RpcSender):

package/dist/src/python/python-runner.py

@@ -5,11 +5,11 @@ import os
 import asyncio
 import traceback
 from typing import Callable, List, Dict
-from rpc import RpcSender
-from context import Context
-from middleware import compose_middleware
-from rpc_stream_manager import RpcStreamManager
-from dot_dict import DotDict
+from motia_rpc import RpcSender
+from motia_context import Context
+from motia_middleware import compose_middleware
+from motia_rpc_stream_manager import RpcStreamManager
+from motia_dot_dict import DotDict
 
 def parse_args(arg: str) -> Dict:
     """Parse command line arguments into HandlerArgs"""

package/package.json

@@ -2,7 +2,7 @@
   "name": "@motiadev/core",
   "description": "Core functionality for the Motia framework, providing the foundation for building event-driven workflows.",
   "main": "dist/index.js",
-  "version": "0.4.2-beta.94",
+  "version": "0.4.3-beta.96",
   "dependencies": {
     "@amplitude/analytics-node": "^1.3.8",
     "body-parser": "^1.20.3",

package/dist/src/python/validation.py

@@ -1,56 +0,0 @@
-from typing import TypeVar, Dict, Any
-from jsonschema import validate as json_validate
-from jsonschema.exceptions import ValidationError
-from type_definitions import ValidationResult, JsonSchema
-
-T = TypeVar('T')
-
-def namespace_to_dict(obj: Any) -> Dict:
-    """Convert SimpleNamespace to dict recursively"""
-    if isinstance(obj, list):
-        return [namespace_to_dict(item) for item in obj]
-    elif hasattr(obj, '__dict__'):
-        return {k: namespace_to_dict(v) for k, v in obj.__dict__.items()}
-    return obj
-
-def create_validation_error(error: ValidationError) -> ValidationResult:
-    """Create a user-friendly validation error message"""
-    property_name = error.path[-1] if error.path else error.schema_path[-1]
-    
-    if error.validator == 'required':
-        missing_field = error.schema['required'][0]
-        error_msg = f"Missing required field: '{missing_field}'"
-    elif error.validator == 'type':
-        expected_type = error.validator_value
-        error_msg = f"Invalid type for '{property_name}'. Expected {expected_type}"
-    elif error.validator == 'properties':
-        error_msg = f"Invalid property: '{property_name}'"
-    elif error.validator == 'items':
-        error_msg = f"Invalid item in array: '{property_name}'"
-    else:
-        error_msg = f"Validation error for '{property_name}': {error.message}"
-
-    details = f"\nReceived: {str(error.instance)}" if hasattr(error, 'instance') else ""
-    
-    return {
-        'success': False,
-        'error': error_msg,
-        'details': details,
-    }
-
-def validate_with_jsonschema(data: T, schema: JsonSchema) -> ValidationResult:
-    """Validate data against a JSON schema"""
-    try:
-        dict_data = namespace_to_dict(data)
-        json_validate(instance=dict_data, schema=schema)
-        return {
-            'success': True,
-            'data': dict_data
-        }
-    except ValidationError as e:
-        return create_validation_error(e)
-    except Exception as e:
-        return {
-            'success': False,
-            'error': f"Validation Error: {str(e)}"
-        }