jac-scale 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

jac_scale/targets/kubernetes/kubernetes_target.jac

@@ -174,10 +174,7 @@ class KubernetesTarget(DeploymentTarget) {
         return service;
     }
 
-    """Build the bash command for setting up Jaseci runtime environment.
-
-    This replaces the hard-coded command with a configurable version.
-    """
+    """Build the bash command for setting up Jaseci runtime environment."""
     def _build_runtime_setup_command(
         self: KubernetesTarget, app_config: AppConfig
     ) -> list[str] {
@@ -188,36 +185,61 @@ class KubernetesTarget(DeploymentTarget) {
         commands.append('export DEBIAN_FRONTEND=noninteractive');
         commands.append('apt-get update');
 
-        # Install base packages
-        base_packages = ['git', 'npm', 'nodejs'];
+        # Install base packages (curl and unzip needed for Bun installation)
+        base_packages = ['git', 'curl', 'unzip'];
         if config.additional_packages {
             base_packages.extend(config.additional_packages);
         }
         commands.append(f"apt-get install -y {' '.join(base_packages)}");
 
-        # Clone and setup Jaseci if enabled
-        if config.install_jaseci {
+        # Install Bun (required for jac-client frontend builds)
+        commands.append('curl -fsSL https://bun.sh/install | bash');
+        commands.append('export BUN_INSTALL="$HOME/.bun"');
+        commands.append('export PATH="$BUN_INSTALL/bin:$PATH"');
+
+        if app_config.experimental {
             commands.append('rm -rf jaseci');
-            # Clone repository
             clone_cmd = f"git clone --branch {config.jaseci_branch} --single-branch {config.jaseci_repo_url}";
             commands.append(clone_cmd);
             commands.append('cd ./jaseci');
-            # Checkout specific commit if provided
             if config.jaseci_commit {
                 commands.append(f"git checkout {config.jaseci_commit}");
             }
-            # Update submodules
             commands.append('git submodule update --init --recursive');
-            # Setup virtual environment
-            commands.append('python -m venv venv');
-            commands.append('source venv/bin/activate');
-            # Install Jaseci components
             commands.append('pip install pluggy');
             commands.append('pip install -e ./jac');
             commands.append('pip install -e ./jac-scale');
             commands.append('pip install -e ./jac-client');
             commands.append('pip install -e ./jac-byllm');
             commands.append('cd ..');
+        } else {
+            packages = config.plugin_versions or {};
+            jaclang_v = packages.get('jaclang', 'latest');
+            scale_v = packages.get('jac_scale', 'latest');
+            client_v = packages.get('jac_client', 'latest');
+            byllm_v = packages.get('jac_byllm', 'latest');
+            if jaclang_v == 'latest' {
+                commands.append('pip install jaclang');
+            } else {
+                commands.append(f'pip install jaclang=={jaclang_v}');
+            }
+            if scale_v == 'latest' {
+                commands.append('pip install jac-scale');
+            } else {
+                commands.append(f'pip install jac-scale=={scale_v}');
+            }
+            if client_v == 'latest' {
+                commands.append('pip install jac-client');
+            } else {
+                commands.append(f'pip install jac-client=={client_v}');
+            }
+            if byllm_v and byllm_v != 'none' {
+                if byllm_v == 'latest' {
+                    commands.append('pip install byllm');
+                } else {
+                    commands.append(f'pip install byllm=={byllm_v}');
+                }
+            }
         }
 
         # Change to app directory (project is already copied there via volume mount)
@@ -641,6 +663,135 @@ class KubernetesTarget(DeploymentTarget) {
         );
     }
 
+    """Wait for resources to be completely deleted."""
+    def _wait_for_deletion(
+        self: KubernetesTarget,
+        app_name: str,
+        namespace: str,
+        apps_v1: Any,
+        core_v1: Any,
+        max_wait: int = 60,
+        poll_interval: float = 1.0
+    ) -> None {
+        elapsed = 0.0;
+        while elapsed < max_wait {
+            resources_exist = False;
+
+            # Check deployment
+            try {
+                apps_v1.read_namespaced_deployment(name=app_name, namespace=namespace);
+                resources_exist = True;
+            } except ApiException as e {
+                if e.status != 404 {
+                    raise ;
+                }
+            }
+
+            # Check service
+            try {
+                core_v1.read_namespaced_service(
+                    name=f"{app_name}-service", namespace=namespace
+                );
+                resources_exist = True;
+            } except ApiException as e {
+                if e.status != 404 {
+                    raise ;
+                }
+            }
+
+            # Check MongoDB resources if enabled
+            if self.k8s_config.mongodb_enabled {
+                mongodb_name = f"{app_name}-mongodb";
+                try {
+                    apps_v1.read_namespaced_stateful_set(
+                        name=mongodb_name, namespace=namespace
+                    );
+                    resources_exist = True;
+                } except ApiException as e {
+                    if e.status != 404 {
+                        raise ;
+                    }
+                }
+                try {
+                    core_v1.read_namespaced_service(
+                        name=f"{mongodb_name}-service", namespace=namespace
+                    );
+                    resources_exist = True;
+                } except ApiException as e {
+                    if e.status != 404 {
+                        raise ;
+                    }
+                }
+            }
+
+            # Check Redis resources if enabled
+            if self.k8s_config.redis_enabled {
+                redis_name = f"{app_name}-redis";
+                try {
+                    apps_v1.read_namespaced_deployment(
+                        name=redis_name, namespace=namespace
+                    );
+                    resources_exist = True;
+                } except ApiException as e {
+                    if e.status != 404 {
+                        raise ;
+                    }
+                }
+                try {
+                    core_v1.read_namespaced_service(
+                        name=f"{redis_name}-service", namespace=namespace
+                    );
+                    resources_exist = True;
+                } except ApiException as e {
+                    if e.status != 404 {
+                        raise ;
+                    }
+                }
+            }
+
+            # Check PVCs
+            try {
+                pvcs = core_v1.list_namespaced_persistent_volume_claim(namespace);
+                for pvc in pvcs.items {
+                    if pvc.metadata.name.startswith(app_name) {
+                        resources_exist = True;
+                        break;
+                    }
+                }
+            } except Exception { }
+
+            # Check code sync pod
+            try {
+                core_v1.read_namespaced_pod(
+                    name=f"{app_name}-code-sync", namespace=namespace
+                );
+                resources_exist = True;
+            } except ApiException as e {
+                if e.status != 404 {
+                    raise ;
+                }
+            }
+
+            # If no resources exist, deletion is complete
+            if not resources_exist {
+                if self.logger {
+                    self.logger.info(
+                        f"All resources for '{app_name}' have been deleted"
+                    );
+                }
+                return;
+            }
+            time.sleep(poll_interval);
+            elapsed = elapsed + poll_interval;
+        }
+
+        if self.logger {
+            self.logger.warn(
+                f"Timeout waiting for resources to be deleted after {max_wait} seconds"
+            );
+        }
+    }
+
     """Destroy all enabled databases."""
     def _destroy_databases(
         self: KubernetesTarget,
@@ -727,6 +878,14 @@ class KubernetesTarget(DeploymentTarget) {
                 }
             }
 
+            # Wait for all resources to be completely deleted
+            if self.logger {
+                self.logger.info(
+                    f"Waiting for all resources to be deleted for '{app_name}'..."
+                );
+            }
+            self._wait_for_deletion(app_name, namespace, apps_v1, core_v1);
+
             if self.logger {
                 self.logger.info(f"Application '{app_name}' destroyed successfully");
             }

jac_scale/tests/fixtures/scale-feats/components/Button.cl.jac

@@ -0,0 +1,32 @@
+"""Button component for the Jac client application."""
+
+def:pub Button(label: str, onClick: any, variant: str = "primary", disabled: bool = False) -> any {
+    base_styles = {
+        "padding": "0.75rem 1.5rem",
+        "fontSize": "1rem",
+        "fontWeight": "600",
+        "borderRadius": "0.5rem",
+        "border": "none",
+        "cursor": "not-allowed" if disabled else "pointer",
+        "transition": "all 0.2s ease"
+    };
+
+    variant_styles = {
+        "primary": {
+            "backgroundColor": "#9ca3af" if disabled else "#3b82f6",
+            "color": "#ffffff"
+        },
+        "secondary": {
+            "backgroundColor": "#e5e7eb" if disabled else "#6b7280",
+            "color": "#ffffff"
+        }
+    };
+
+    return <button
+        style={{**base_styles, **variant_styles[variant]}}
+        onClick={onClick}
+        disabled={disabled}
+    >
+        {label}
+    </button>;
+}

jac_scale/tests/fixtures/scale-feats/main.jac

@@ -0,0 +1,147 @@
+"""jac-scale features test fixture.
+
+Demonstrates jac-scale specific features that require FastAPI:
+- Storage abstraction with file uploads
+- UploadFile handling
+"""
+
+import from fastapi { UploadFile }
+import from uuid { uuid4 }
+
+# Initialize storage with custom base path
+glob storage = store(base_path="./uploads");
+
+# ============================================================================
+# Storage API Walkers
+# ============================================================================
+
+"""Upload a file to storage."""
+walker:pub upload_file {
+    has file: UploadFile;
+    has folder: str = "documents";
+
+    can process with `root entry {
+        # Generate unique filename
+        ext = self.file.filename.rsplit(".", 1)[-1] if "." in self.file.filename else "";
+        unique_name = f"{uuid4()}.{ext}" if ext else str(uuid4());
+        path = f"{self.folder}/{unique_name}";
+
+        # Upload file to storage
+        storage.upload(self.file.file, path);
+
+        # Get metadata
+        metadata = storage.get_metadata(path);
+
+        report {
+            "success": True,
+            "original_filename": self.file.filename,
+            "storage_path": path,
+            "size": metadata["size"],
+            "content_type": self.file.content_type
+        };
+    }
+}
+
+"""List files in storage."""
+walker:pub list_files {
+    has folder: str = "";
+    has recursive: bool = False;
+
+    can process with `root entry {
+        files = [];
+        for path in storage.list_files(self.folder, self.recursive) {
+            metadata = storage.get_metadata(path);
+            files.append({
+                "path": path,
+                "size": metadata["size"],
+                "modified": str(metadata["modified"])
+            });
+        }
+        report {"files": files, "count": len(files)};
+    }
+}
+
+"""Delete a file from storage."""
+walker:pub delete_file {
+    has path: str;
+
+    can process with `root entry {
+        if not storage.exists(self.path) {
+            report {"success": False, "error": "File not found"};
+            return;
+        }
+        deleted = storage.delete(self.path);
+        report {"success": deleted, "path": self.path};
+    }
+}
+
+"""Download a file from storage."""
+walker:pub download_file {
+    has path: str;
+
+    can process with `root entry {
+        if not storage.exists(self.path) {
+            report {"success": False, "error": "File not found"};
+            return;
+        }
+        content = storage.download(self.path);
+        metadata = storage.get_metadata(self.path);
+        report {
+            "success": True,
+            "path": self.path,
+            "size": metadata["size"],
+            "content_length": len(content) if content else 0
+        };
+    }
+}
+
+"""Check if a file exists in storage."""
+walker:pub file_exists {
+    has path: str;
+
+    can process with `root entry {
+        exists = storage.exists(self.path);
+        report {"path": self.path, "exists": exists};
+    }
+}
+
+"""Copy a file within storage."""
+walker:pub copy_file {
+    has source: str;
+    has destination: str;
+
+    can process with `root entry {
+        if not storage.exists(self.source) {
+            report {"success": False, "error": "Source file not found"};
+            return;
+        }
+        result = storage.copy(self.source, self.destination);
+        report {"success": result, "source": self.source, "destination": self.destination};
+    }
+}
+
+"""Move a file within storage."""
+walker:pub move_file {
+    has source: str;
+    has destination: str;
+
+    can process with `root entry {
+        if not storage.exists(self.source) {
+            report {"success": False, "error": "Source file not found"};
+            return;
+        }
+        result = storage.move(self.source, self.destination);
+        report {"success": result, "source": self.source, "destination": self.destination};
+    }
+}
+
+# ============================================================================
+# Health Check
+# ============================================================================
+
+"""Simple health check walker."""
+walker:pub health {
+    can check with `root entry {
+        report {"status": "ok", "features": ["storage", "file_upload"]};
+    }
+}

jac_scale/tests/fixtures/test_api.jac

@@ -89,6 +89,35 @@ walker : pub PublicInfo {
     }
 }
 
+# Streaming Walker Test
+walker : pub WalkerStream {
+    has count: int = 3;
+
+    can stream_reports with `root entry {
+        def stream -> str {
+            import time;
+            for i in range(self.count) {
+                time.sleep(0.5);
+                yield f"Report {i}";
+            }
+        }
+        report stream();
+    }
+}
+
+import from typing { Generator }
+# Streaming function test
+def : pub FunctionStream(count: int = 3) -> Generator {
+    import time;
+    def stream -> Generator {
+        for i in range(count) {
+            time.sleep(0.5);
+            yield f"Func {i}";
+        }
+    }
+    report stream();
+}
+
 # Async Walker Test
 import asyncio;
 

jac_scale/tests/fixtures/test_restspec.jac

@@ -0,0 +1,37 @@
+
+"""Test API fixture for restspec decorator tests."""
+
+import from jaclang.runtimelib.builtin { restspec }
+import from http { HTTPMethod }
+
+# ============================================================================
+# RestSpec Decorator Tests
+# ============================================================================
+
+"""Walker with GET method via restspec decorator."""
+@restspec(method=HTTPMethod.GET)
+walker : pub GetWalker {
+    can get_data with `root entry {
+        report {"message": "GetWalker executed", "method": "GET"};
+    }
+}
+
+"""Walker with custom path."""
+@restspec(method=HTTPMethod.GET, path="/custom/walker")
+walker : pub CustomPathWalker {
+    can get_data with `root entry {
+        report {"message": "CustomPathWalker executed", "path": "/custom/walker"};
+    }
+}
+
+"""Function with GET method via restspec decorator."""
+@restspec(method=HTTPMethod.GET)
+def get_func() -> dict {
+    return {"message": "get_func executed", "method": "GET"};
+}
+
+"""Function with custom path."""
+@restspec(method=HTTPMethod.GET, path="/custom/func")
+def custom_path_func() -> dict {
+    return {"message": "custom_path_func executed", "path": "/custom/func"};
+}

jac_scale/tests/test_deploy_k8s.py

@@ -97,10 +97,12 @@ def test_deploy_all_in_one():
     )
 
     # Create app config
+    # Use experimental=True to install from repo (PyPI packages may not be available)
     app_config = AppConfig(
         code_folder=todo_app_path,
         file_name="main.jac",
         build=False,
+        experimental=True,
     )
 
     # Deploy using new architecture
@@ -172,7 +174,6 @@ def test_deploy_all_in_one():
 
     # Cleanup using new architecture
     deployment_target.destroy(app_name)
-    time.sleep(60)  # Wait for deletion to propagate
 
     # Verify cleanup - resources should no longer exist
     try: