flowyml 1.2.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

flowyml/stacks/registry.py

@@ -214,6 +214,27 @@ def get_active_stack() -> Stack | None:
     Returns:
         Active stack or None
     """
+    # Check for remote execution mode in global config
+    from flowyml.utils.config import get_config
+
+    config = get_config()
+
+    if config.execution_mode == "remote" and config.remote_server_url:
+        # Dynamically create a remote logging stack
+        from flowyml.core.executor import LocalExecutor
+        from flowyml.storage.remote import RemoteMetadataStore, RemoteArtifactStore
+        from flowyml.stacks.base import Stack
+        import os
+
+        api_token = os.getenv("FLOWYML_API_TOKEN")
+
+        return Stack(
+            name="remote_logging",
+            executor=LocalExecutor(),
+            metadata_store=RemoteMetadataStore(api_url=config.remote_server_url, api_token=api_token),
+            artifact_store=RemoteArtifactStore(api_url=config.remote_server_url, api_token=api_token),
+        )
+
     return get_registry().get_active_stack()
 
 

flowyml/storage/artifacts.py

@@ -215,7 +215,7 @@ class LocalArtifactStore(ArtifactStore):
         from datetime import datetime
         from flowyml.storage.materializers.base import get_materializer
         import shutil
-        import pickle
+        import cloudpickle
         import json
 
         date_str = datetime.now().strftime("%Y-%m-%d")
@@ -236,11 +236,21 @@ class LocalArtifactStore(ArtifactStore):
         if materializer:
             materializer.save(obj, full_path)
         else:
-            # Fallback to pickle
-            with open(full_path / "data.pkl", "wb") as f:
-                pickle.dump(obj, f)
+            # Fallback to cloudpickle (more robust than pickle)
+            fallback_file = full_path / "data.pkl"
+            with open(fallback_file, "wb") as f:
+                cloudpickle.dump(obj, f)
             # Save metadata
             with open(full_path / "metadata.json", "w") as f:
-                json.dump({"type": "pickle", "format": "pickle"}, f, indent=2)
+                json.dump(
+                    {
+                        "type": type(obj).__name__,
+                        "serializer": "cloudpickle",
+                        "format": "pickle",
+                        "file": fallback_file.name,
+                    },
+                    f,
+                    indent=2,
+                )
 
         return str(full_path)

flowyml/storage/materializers/__init__.py

@@ -7,6 +7,7 @@ from flowyml.storage.materializers.sklearn import SklearnMaterializer
 from flowyml.storage.materializers.pandas import PandasMaterializer
 from flowyml.storage.materializers.numpy import NumPyMaterializer
 from flowyml.storage.materializers.keras import KerasMaterializer
+from flowyml.storage.materializers.cloudpickle import CloudpickleMaterializer
 
 __all__ = [
     "BaseMaterializer",
@@ -17,4 +18,5 @@ __all__ = [
     "PandasMaterializer",
     "NumPyMaterializer",
     "KerasMaterializer",
+    "CloudpickleMaterializer",
 ]

flowyml/storage/materializers/base.py

@@ -99,6 +99,27 @@ class MaterializerRegistry:
 
         return None
 
+    def get_materializer_by_type_name(self, type_name: str) -> BaseMaterializer | None:
+        """Get materializer by type name string.
+
+        Args:
+            type_name: Full type name (e.g. 'pandas.core.frame.DataFrame')
+
+        Returns:
+            Materializer instance or None
+        """
+        # Check if we have a direct mapping
+        if type_name in self._materializers:
+            return self._materializers[type_name]()
+
+        # Try to find by just class name if full path fails (less reliable but useful fallback)
+        simple_name = type_name.split(".")[-1]
+        for key, materializer_cls in self._materializers.items():
+            if key.split(".")[-1] == simple_name:
+                return materializer_cls()
+
+        return None
+
     def list_materializers(self) -> dict[str, type[BaseMaterializer]]:
         """List all registered materializers.
 
@@ -131,3 +152,15 @@ def get_materializer(obj: Any) -> BaseMaterializer | None:
         Materializer instance or None
     """
     return materializer_registry.get_materializer(obj)
+
+
+def get_materializer_by_type_name(type_name: str) -> BaseMaterializer | None:
+    """Get materializer by type name string from global registry.
+
+    Args:
+        type_name: Full type name (e.g. 'pandas.core.frame.DataFrame')
+
+    Returns:
+        Materializer instance or None
+    """
+    return materializer_registry.get_materializer_by_type_name(type_name)

flowyml/storage/materializers/cloudpickle.py

@@ -0,0 +1,74 @@
+"""Cloudpickle materializer for robust Python object serialization."""
+
+from pathlib import Path
+from typing import Any
+
+from flowyml.storage.materializers.base import BaseMaterializer
+
+try:
+    import cloudpickle
+
+    CLOUDPICKLE_AVAILABLE = True
+except ImportError:
+    CLOUDPICKLE_AVAILABLE = False
+
+
+if CLOUDPICKLE_AVAILABLE:
+
+    class CloudpickleMaterializer(BaseMaterializer):
+        """Materializer using cloudpickle for robust serialization."""
+
+        def save(self, obj: Any, path: Path) -> None:
+            """Save object using cloudpickle.
+
+            Args:
+                obj: Object to save
+                path: Directory path where object should be saved
+            """
+            path.mkdir(parents=True, exist_ok=True)
+
+            file_path = path / "data.cloudpickle"
+            with open(file_path, "wb") as f:
+                cloudpickle.dump(obj, f)
+
+        def load(self, path: Path) -> Any:
+            """Load object using cloudpickle.
+
+            Args:
+                path: Directory path from which to load object
+
+            Returns:
+                Loaded object
+            """
+            file_path = path / "data.cloudpickle"
+            if not file_path.exists():
+                raise FileNotFoundError(f"Cloudpickle file not found at {file_path}")
+
+            with open(file_path, "rb") as f:
+                return cloudpickle.load(f)
+
+        @classmethod
+        def supported_types(cls) -> list[type]:
+            """Return types supported by this materializer.
+
+            Cloudpickle can handle almost anything, so we expose ``object`` here
+            for consumers that explicitly opt into this materializer as a
+            fallback, but it is not registered automatically with the global
+            registry to avoid hijacking unknown types.
+            """
+            return [object]
+
+else:
+
+    class CloudpickleMaterializer(BaseMaterializer):
+        """Placeholder when cloudpickle is not available."""
+
+        def save(self, obj: Any, path: Path) -> None:
+            raise ImportError("cloudpickle is not installed")
+
+        def load(self, path: Path) -> Any:
+            raise ImportError("cloudpickle is not installed")
+
+        @classmethod
+        def supported_types(cls) -> list[type]:
+            return []