jac-scale 0.1.2__tar.gz → 0.1.3__tar.gz

{jac_scale-0.1.2 → jac_scale-0.1.3}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: jac-scale
-Version: 0.1.2
+Version: 0.1.3
 Author-email: Jason Mars <jason@mars.ninja>
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
-Requires-Dist: jaclang>=0.9.11
+Requires-Dist: jaclang>=0.9.12
 Requires-Dist: python-dotenv<2.0.0,>=1.2.1
 Requires-Dist: docker<8.0.0,>=7.1.0
 Requires-Dist: kubernetes<35.0.0,>=34.1.0

{jac_scale-0.1.2 → jac_scale-0.1.3}/jac_scale/abstractions/config/app_config.jac

@@ -7,7 +7,8 @@ class AppConfig {
         file_name: str = 'none',
         build: bool = False,
         app_name: (str | None) = None,
-        testing: bool = False;
+        testing: bool = False,
+        experimental: bool = False;
 
     def init(
         self: AppConfig,
@@ -15,13 +16,15 @@ class AppConfig {
         file_name: str = 'none',
         build: bool = False,
         app_name: (str | None) = None,
-        testing: bool = False
+        testing: bool = False,
+        experimental: bool = False
     ) -> None {
         self.code_folder = code_folder;
         self.file_name = file_name;
         self.build = build;
         self.app_name = app_name;
         self.testing = testing;
+        self.experimental = experimental;
     }
 
     def get_code_path(self: AppConfig) -> Path {

{jac_scale-0.1.2 → jac_scale-0.1.3}/jac_scale/context.jac

@@ -1,8 +1,9 @@
+import from contextvars { ContextVar }
 import from dataclasses { MISSING }
 import from typing { Any }
 import from uuid { UUID }
 import from jaclang.pycore.constant { Constants as Con }
-import from jaclang.runtimelib.context { ExecutionContext }
+import from jaclang.runtimelib.context { ExecutionContext, CallState }
 
 """Jac Scale Execution Context with custom memory backend.
 

jac_scale-0.1.3/jac_scale/factories/storage_factory.jac

@@ -0,0 +1,75 @@
+"""Factory for creating storage instances."""
+import from typing { Any }
+import os;
+import from jaclang.runtimelib.storage { Storage }
+import from jaclang.project.config { get_config }
+
+enum StorageType {
+    LOCAL = "local"
+    # Future: S3, GCS, AZURE - add when implemented
+}
+
+"""Factory for creating storage instances.
+
+Configuration priority: jac.toml > environment variable > default
+
+In jac.toml:
+    [storage]
+    type = "local"  # or "s3", "gcs", "azure"
+    base_path = "/data/storage"
+    create_dirs = true
+
+Environment variables:
+    JAC_STORAGE_TYPE: Storage type (local, s3, gcs, azure)
+    JAC_STORAGE_PATH: Base directory for local storage
+    JAC_STORAGE_CREATE_DIRS: Whether to auto-create directories
+"""
+class StorageFactory {
+    static def create(
+        storage_type: (StorageType | str), config: (dict[str, Any] | None) = None
+    ) -> Storage {
+        # Convert string to enum if needed
+        if isinstance(storage_type, str) {
+            storage_type = StorageType(storage_type);
+        }
+
+        if storage_type == StorageType.LOCAL {
+            import from jaclang.runtimelib.storage { LocalStorage }
+            cfg = config or {};
+            return LocalStorage(
+                base_path=cfg.get("base_path", "./storage"),
+                create_dirs=cfg.get("create_dirs", True)
+            );
+        }
+        raise ValueError(f"Unsupported storage type: {storage_type}") ;
+    }
+
+    static def get_default(
+        base_path: str = "./storage", create_dirs: bool = True
+    ) -> Storage {
+        # Get config from jac.toml if available
+        jac_config = get_config();
+
+        # Config priority: jac.toml > env var > parameter
+        if jac_config and jac_config.storage {
+            storage_type = StorageType(jac_config.storage.storage_type);
+            base_path = jac_config.storage.base_path;
+            create_dirs = jac_config.storage.create_dirs;
+        } elif os.environ.get("JAC_STORAGE_TYPE") or os.environ.get("JAC_STORAGE_PATH") {
+            storage_type_str = os.environ.get(
+                "JAC_STORAGE_TYPE", StorageType.LOCAL.value
+            );
+            storage_type = StorageType(storage_type_str);
+            base_path = os.environ.get("JAC_STORAGE_PATH", base_path);
+            create_dirs_str = os.environ.get(
+                "JAC_STORAGE_CREATE_DIRS", str(create_dirs)
+            );
+            create_dirs = create_dirs_str.lower() == "true";
+        } else {
+            storage_type = StorageType.LOCAL;
+        }
+
+        storage_config = {"base_path": base_path, "create_dirs": create_dirs};
+        return StorageFactory.create(storage_type, storage_config);
+    }
+}

{jac_scale-0.1.2 → jac_scale-0.1.3}/jac_scale/impl/context.impl.jac

@@ -21,4 +21,7 @@ impl JScaleExecutionContext.init(self: JScaleExecutionContext) -> None {
     # Default user_root and entry_node to system_root
     self.user_root = self.system_root;
     self.entry_node = self.system_root;
+    self.call_state: ContextVar[CallState] = ContextVar(
+        'call_state', default=CallState()
+    );
 }

{jac_scale-0.1.2 → jac_scale-0.1.3}/jac_scale/impl/serve.impl.jac

@@ -486,10 +486,17 @@ impl JacAPIServer.render_base_route_callback(
 
 impl JacAPIServer.register_functions_endpoints -> None {
     for func_name in self.get_functions() {
+        func_obj = self.get_functions()[func_name];
+        restspec = func_obj.restspec if func_obj?.restspec else None;
+        spec_method = restspec.method if restspec else HTTPMethod.POST;
+        spec_path = restspec.path if restspec else None;
+
+        final_path = spec_path or f"/function/{func_name}";
+
         self.server.add_endpoint(
             JEndPoint(
-                method=HTTPMethod.POST,
-                path=f"/function/{func_name}",
+                method=spec_method,
+                path=final_path,
                 callback=self.create_function_callback(func_name),
                 parameters=self.create_function_parameters(func_name),
                 response_model=None,
@@ -546,7 +553,7 @@ impl JacAPIServer.create_function_callback(
 ) -> Callable[..., TransportResponse] {
     import from jaclang.runtimelib.transport { TransportResponse, Meta }
     requires_auth = self.introspector.is_auth_required_for_function(func_name);
-    def callback(**kwargs: JsonValue) -> TransportResponse {
+    async def callback(**kwargs: JsonValue) -> TransportResponse {
         username: (str | None) = None;
         if requires_auth {
             authorization = kwargs.pop('Authorization', None);
@@ -568,9 +575,21 @@ impl JacAPIServer.create_function_callback(
             }
         }
         print(f"Executing function '{func_name}' with params: {kwargs}");
-        result = self.execution_manager.execute_function(
+        result = await self.execution_manager.execute_function(
             self.get_functions()[func_name], kwargs, (username or '__guest__')
         );
+        # Handle streaming responses (generators/async generators)
+        if (isgenerator(result) or isinstance(result, AsyncGenerator)) {
+            return StreamingResponse(
+                result,
+                media_type='text/event-stream',
+                headers={
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'close',
+                    'X-Accel-Buffering': 'no'
+                }
+            );
+        }
         if 'error' in result {
             return TransportResponse.fail(
                 code='EXECUTION_ERROR',
@@ -588,10 +607,15 @@ impl JacAPIServer.create_function_callback(
 
 impl JacAPIServer.register_walkers_endpoints -> None {
     for walker_name in self.get_walkers() {
+        walker_cls = self.get_walkers()[walker_name];
+        restspec = walker_cls.restspec if walker_cls?.restspec else None;
+        spec_method = restspec.method if restspec?.method else HTTPMethod.POST;
+        spec_path = restspec.path if restspec?.path else f"/walker/{walker_name}";
+
         self.server.add_endpoint(
             JEndPoint(
-                method=HTTPMethod.POST,
-                path=f"/walker/{walker_name}/{{node}}",
+                method=spec_method,
+                path=f"{spec_path}/{{node}}",
                 callback=self.create_walker_callback(walker_name, has_node_param=True),
                 parameters=self.create_walker_parameters(
                     walker_name, invoke_on_root=False
@@ -604,8 +628,8 @@ impl JacAPIServer.register_walkers_endpoints -> None {
         );
         self.server.add_endpoint(
             JEndPoint(
-                method=HTTPMethod.POST,
-                path=f"/walker/{walker_name}",
+                method=spec_method,
+                path=spec_path,
                 callback=self.create_walker_callback(walker_name, has_node_param=False),
                 parameters=self.create_walker_parameters(
                     walker_name, invoke_on_root=True
@@ -700,6 +724,17 @@ impl JacAPIServer.create_walker_callback(
         result = await self.execution_manager.spawn_walker(
             self.get_walkers()[walker_name], kwargs, (username or '__guest__')
         );
+        if (isgenerator(result) or isinstance(result, AsyncGenerator)) {
+            return StreamingResponse(
+                result,
+                media_type='text/event-stream',
+                headers={
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'close',
+                    'X-Accel-Buffering': 'no'
+                }
+            );
+        }
         if 'error' in result {
             return TransportResponse.fail(
                 code='EXECUTION_ERROR',
@@ -1260,6 +1295,20 @@ impl JacAPIServer.register_dynamic_walker_endpoint -> None {
         result = await self.execution_manager.spawn_walker(
             walkers[walker_name], kwargs, (username or '__guest__')
         );
+
+        # Handle streaming responses (generators/async generators)
+        if (isgenerator(result) or isinstance(result, AsyncGenerator)) {
+            return StreamingResponse(
+                result,
+                media_type='text/event-stream',
+                headers={
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'close',
+                    'X-Accel-Buffering': 'no'
+                }
+            );
+        }
+
         if 'error' in result {
             return TransportResponse.fail(
                 code='EXECUTION_ERROR',
@@ -1401,9 +1450,21 @@ impl JacAPIServer.register_dynamic_function_endpoint -> None {
             }
         }
 
-        result = self.execution_manager.execute_function(
+        result = await self.execution_manager.execute_function(
             functions[function_name], kwargs, (username or '__guest__')
         );
+        # Handle streaming responses (generators/async generators)
+        if (isgenerator(result) or isinstance(result, AsyncGenerator)) {
+            return StreamingResponse(
+                result,
+                media_type='text/event-stream',
+                headers={
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'close',
+                    'X-Accel-Buffering': 'no'
+                }
+            );
+        }
         if 'error' in result {
             return TransportResponse.fail(
                 code='EXECUTION_ERROR',

{jac_scale-0.1.2 → jac_scale-0.1.3}/jac_scale/memory_hierarchy.jac

@@ -74,7 +74,9 @@ MongoDB persistence backend - implements PersistentMemory for durable L3 storage
 Replaces SqliteMemory when MongoDB is available.
 """
 obj MongoBackend(PersistentMemory) {
-    has client: (MongoClient | None) = None,
+    has client: MongoClient | None = None,
+        db: Any by postinit,
+        collection: Any by postinit,
         db_name: str = 'jac_db',
         collection_name: str = 'anchors',
         mongo_url: str = _db_config['mongodb_uri'];

{jac_scale-0.1.2 → jac_scale-0.1.3}/jac_scale/plugin.jac

@@ -4,6 +4,7 @@ import pathlib;
 import from dotenv { load_dotenv }
 import from jaclang.cli.registry { get_registry }
 import from jaclang.cli.command { Arg, ArgKind, CommandPriority, HookContext }
+import from jaclang.cli.console { console }
 import from jaclang.pycore.runtime { hookimpl, plugin_manager }
 import from jaclang.runtimelib.context { ExecutionContext }
 import from jaclang.runtimelib.server { JacAPIServer as JacServer }
@@ -17,6 +18,7 @@ import from .factories.utility_factory { UtilityFactory }
 import from .abstractions.config.app_config { AppConfig }
 import from .user_manager { JacScaleUserManager }
 import from jaclang.runtimelib.server { UserManager }
+import from jaclang.runtimelib.storage { Storage }
 
 """Pre-hook for jac start command to handle --scale flag."""
 def _scale_pre_hook(context: HookContext) -> None {
@@ -25,6 +27,7 @@ def _scale_pre_hook(context: HookContext) -> None {
         # Handle deployment instead of local server
         filename = context.get_arg("filename");
         build = context.get_arg("build", False);
+        experimental = context.get_arg("experimental", False);
         target = context.get_arg("target", "kubernetes");
         registry = context.get_arg("registry", "dockerhub");
         if not os.path.exists(filename) {
@@ -59,15 +62,27 @@ def _scale_pre_hook(context: HookContext) -> None {
         }
         # Create app config
         app_config = AppConfig(
-            code_folder=code_folder, file_name=base_file_path, build=build
+            code_folder=code_folder,
+            file_name=base_file_path,
+            build=build,
+            experimental=experimental
         );
+        if experimental {
+            console.print(
+                "Installing Jaseci packages from repository (experimental mode)..."
+            );
+        } else {
+            console.print("Installing Jaseci packages from PyPI...");
+        }
         # Deploy
         result = deployment_target.deploy(app_config);
         if not result.success {
             raise RuntimeError(result.message or "Deployment failed") ;
         }
         if result.service_url {
-            print(f"Deployment complete! Service available at: {result.service_url}");
+            console.print(
+                f"Deployment complete! Service available at: {result.service_url}"
+            );
         }
         # Cancel normal start execution since we handled it
         context.set_data("cancel_execution", True);
@@ -101,6 +116,13 @@ class JacCmd {
                     help="Build and push Docker image (with --scale)",
                     short="b"
                 ),
+                Arg.create(
+                    "experimental",
+                    typ=bool,
+                    default=False,
+                    help="Use experimental mode (install from repo instead of PyPI)",
+                    short="e"
+                ),
                 Arg.create(
                     "target",
                     typ=str,
@@ -168,7 +190,9 @@ class JacCmd {
             app_name = os.getenv('APP_NAME') or target_config.get('app_name', 'jaseci');
             deployment_target.destroy(app_name);
 
-            print(f"Successfully destroyed deployment '{app_name}' from {target}");
+            console.print(
+                f"Successfully destroyed deployment '{app_name}' from {target}"
+            );
             return 0;
         }
     }
@@ -205,6 +229,17 @@ class JacScalePlugin {
     static def get_user_manager(base_path: str) -> UserManager {
         return JacScaleUserManager(base_path=base_path);
     }
+
+    """Provide jac-scale's storage backend.
+
+    This overrides the core store() to use jac-scale's StorageFactory,
+    which supports cloud backends (S3, GCS, Azure) via configuration.
+    """
+    @hookimpl
+    static def store(base_path: str = "./storage", create_dirs: bool = True) -> Storage {
+        import from .factories.storage_factory { StorageFactory }
+        return StorageFactory.get_default(base_path, create_dirs);
+    }
 }
 
 # Pluggy's varnames() puts parameters with defaults into kwargnames, not argnames.

{jac_scale-0.1.2 → jac_scale-0.1.3}/jac_scale/plugin_config.jac

@@ -149,6 +149,33 @@ class JacScalePluginConfig {
                             "type": "bool",
                             "default": True,
                             "description": "Enable Redis deployment in Kubernetes"
+                        },
+                        "plugin_versions": {
+                            "type": "dict",
+                            "default": {},
+                            "description": "Package versions for PyPI installation (default mode). Use 'latest' or specific version.",
+                            "nested": {
+                                "jaclang": {
+                                    "type": "string",
+                                    "default": "latest",
+                                    "description": "jaclang package version"
+                                },
+                                "jac_scale": {
+                                    "type": "string",
+                                    "default": "latest",
+                                    "description": "jac-scale package version"
+                                },
+                                "jac_client": {
+                                    "type": "string",
+                                    "default": "latest",
+                                    "description": "jac-client package version"
+                                },
+                                "jac_byllm": {
+                                    "type": "string",
+                                    "default": "latest",
+                                    "description": "jac-byllm package version (use 'none' to skip)"
+                                }
+                            }
                         }
                     }
                 },

{jac_scale-0.1.2 → jac_scale-0.1.3}/jac_scale/serve.jac

@@ -24,6 +24,9 @@ import from enum { StrEnum }
 import from fastapi_sso.sso.google { GoogleSSO }
 import from jac_scale.utils { generate_random_password }
 import from jac_scale.config_loader { get_scale_config }
+import from typing { AsyncGenerator }
+import from inspect { isgenerator }
+import from fastapi.responses { StreamingResponse }
 
 # Load configuration from jac.toml with env var overrides
 glob _jwt_config = get_scale_config().get_jwt_config(),

{jac_scale-0.1.2 → jac_scale-0.1.3}/jac_scale/targets/kubernetes/kubernetes_config.jac

@@ -34,12 +34,12 @@ class KubernetesConfig(BaseConfig) {
         app_mount_path: str = '/app',
         code_mount_path: str = '/code',
         workspace_path: str = '/code/workspace',
-        # Runtime environment (defaults to official Jaseci repo)
         jaseci_repo_url: str = 'https://github.com/jaseci-labs/jaseci.git',
         jaseci_branch: str = 'main',
         jaseci_commit: (str | None) = None,
         install_jaseci: bool = True,
-        additional_packages: list[str] = [];
+        additional_packages: list[str] = [],
+        plugin_versions: dict[str, str] = {};
 
     def init(
         self: KubernetesConfig,
@@ -75,12 +75,8 @@ class KubernetesConfig(BaseConfig) {
         jaseci_branch: str = 'main',
         jaseci_commit: (str | None) = None,
         install_jaseci: bool = True,
-        additional_packages: list[str] = []
-        # Runtime configuration
-        # Storage configuration
-        # Timing configuration
-        # Paths
-        # Runtime environment
+        additional_packages: list[str] = [],
+        plugin_versions: dict[str, str] = {}
     ) -> None {
         self.app_name = app_name;
         self.namespace = namespace;
@@ -121,6 +117,7 @@ class KubernetesConfig(BaseConfig) {
         self.jaseci_commit = jaseci_commit;
         self.install_jaseci = install_jaseci;
         self.additional_packages = additional_packages;
+        self.plugin_versions = plugin_versions;
     }
 
     override def to_dict(self: KubernetesConfig) -> dict[str, Any] {
@@ -162,7 +159,8 @@ class KubernetesConfig(BaseConfig) {
                 'jaseci_branch': self.jaseci_branch,
                 'jaseci_commit': self.jaseci_commit,
                 'install_jaseci': self.install_jaseci,
-                'additional_packages': self.additional_packages
+                'additional_packages': self.additional_packages,
+                'plugin_versions': self.plugin_versions
             }
         );
         return base;
@@ -204,12 +202,8 @@ class KubernetesConfig(BaseConfig) {
             jaseci_branch=config.get('jaseci_branch', 'main'),
             jaseci_commit=config.get('jaseci_commit'),
             install_jaseci=config.get('install_jaseci', True),
-            additional_packages=config.get('additional_packages', [])
-            # Runtime configuration
-            # Storage configuration
-            # Timing configuration
-            # Paths
-            # Runtime environment
+            additional_packages=config.get('additional_packages', []),
+            plugin_versions=config.get('plugin_versions', {})
         );
     }
 }