jac-scale 0.1.1__py3-none-any.whl

jac_scale/jserver/impl/jserver.impl.jac

@@ -0,0 +1,79 @@
+"""Handle execution of a DELETE endpoint."""
+
+impl JServer._delete(self: JServer, endpoint: JEndPoint) -> 'JServer[T]' {
+    ;
+}
+
+"""Handle execution of a PATCH endpoint."""
+impl JServer._patch(self: JServer, endpoint: JEndPoint) -> 'JServer[T]' {
+    ;
+}
+
+"""Handle execution of a PUT endpoint."""
+impl JServer._put(self: JServer, endpoint: JEndPoint) -> 'JServer[T]' {
+    ;
+}
+
+"""Handle execution of a POST endpoint."""
+impl JServer._post(self: JServer, endpoint: JEndPoint) -> 'JServer[T]' {
+    ;
+}
+
+"""Handle execution of a GET endpoint."""
+impl JServer._get(self: JServer, endpoint: JEndPoint) -> 'JServer[T]' {
+    ;
+}
+
+"""
+Execute the provided endpoints by calling the appropriate HTTP method handlers.
+
+This method iterates through the endpoint list and calls the appropriate
+method (get, post, put, patch, delete) based on each endpoint's HTTP method.
+"""
+impl JServer.execute(self: JServer) -> None {
+    for endpoint in self._endpoints {
+        if (endpoint.method == HTTPMethod.GET) {
+            self._get(endpoint);
+        } elif (endpoint.method == HTTPMethod.POST) {
+            self._post(endpoint);
+        } elif (endpoint.method == HTTPMethod.PUT) {
+            self._put(endpoint);
+        } elif (endpoint.method == HTTPMethod.PATCH) {
+            self._patch(endpoint);
+        } elif (endpoint.method == HTTPMethod.DELETE) {
+            self._delete(endpoint);
+        }
+    }
+}
+
+"""
+Add a single endpoint to the server implementation.
+
+Args:
+endpoint (JEndPoint): The endpoint to add
+"""
+impl JServer.add_endpoint(self: JServer, endpoint: JEndPoint) -> None {
+    self._endpoints.append(endpoint);
+}
+
+"""
+Return the list of registered endpoints.
+This method should return only the endpoints that have been registered
+with this server implementation, not create new ones.
+
+Returns:
+List[JEndPoint]: List of registered endpoint definitions
+"""
+impl JServer.get_endpoints(self: JServer) -> list[JEndPoint] {
+    return self._endpoints;
+}
+
+"""
+Initialize the server with a list of endpoints.
+Args:
+end_points (list[JEndPoint]): List of endpoint definitions to register
+"""
+impl JServer.init(self: JServer, end_points: list[JEndPoint]) -> None {
+    super.init();
+    self._endpoints = end_points;
+}

jac_scale/jserver/jfast_api.jac

@@ -0,0 +1,162 @@
+"""
+JFastApiServer: A FastAPI Implementation of JServer
+
+This module provides a FastAPI-specific implementation of the JServer abstract base class.
+It handles endpoint registration with FastAPI applications and provides all the FastAPI-specific
+functionality like parameter injection, response model generation, and route creation.
+
+Key Components:
+- JFastApiServer: FastAPI implementation of JServer
+- create_app(): Creates a basic FastAPI application for demonstration
+
+Advanced Features:
+- Parameter injection with type conversion
+- Response model generation from JSON schema
+- Support for async/sync callback functions
+- Automatic OpenAPI documentation generation
+- Integration with JAC pass execution patterns
+"""
+
+import inspect;
+import logging;
+import uvicorn;
+import from collections.abc { Callable }
+import from typing { Any, Optional, TypeAlias, get_type_hints }
+import from fastapi {
+    Body,
+    FastAPI,
+    File,
+    Form,
+    Header,
+    HTTPException,
+    Path,
+    Query,
+    Request,
+    UploadFile
+}
+import from fastapi.responses { Response, JSONResponse }
+import from pydantic { BaseModel, Field, create_model }
+import from .jserver { APIParameter, HTTPMethod, JEndPoint, JServer, ParameterType }
+import from jaclang.runtimelib.transport { TransportResponse }
+
+glob EndpointResponse: TypeAlias = Response | BaseModel | <>dict[(str, object)] | <>list[
+         object
+     ] | str | <>bytes | None;
+
+"""Base protocol for parameter handlers."""
+obj ParameterHandler {
+    has type_converter: JFastApiServer;
+
+    """Generate parameter string for FastAPI function signature."""
+    def generate_param_string(param: APIParameter) -> str;
+
+    """Get the actual Python type from parameter type string."""
+    def get_type(param: APIParameter) -> type[Any] {
+        return self.type_converter._get_python_type(param.data_type);
+    }
+
+    """Get the type name for code generation."""
+    def get_type_name(param: APIParameter) -> str {
+        return self.get_type(param).__name__;
+    }
+}
+
+"""Handler for PATH parameters."""
+obj PathParameterHandler(ParameterHandler) {
+    def generate_param_string(param: APIParameter) -> str;
+}
+
+"""Handler for QUERY parameters."""
+obj QueryParameterHandler(ParameterHandler) {
+    def generate_param_string(param: APIParameter) -> str;
+}
+
+"""Handler for HEADER parameters."""
+obj HeaderParameterHandler(ParameterHandler) {
+    def generate_param_string(param: APIParameter) -> str;
+}
+
+"""Handler for FILE parameters."""
+obj FileParameterHandler(ParameterHandler) {
+    def generate_param_string(param: APIParameter) -> str;
+}
+
+"""Handler for BODY parameters with files (multipart/form-data)."""
+obj FormBodyParameterHandler(ParameterHandler) {
+    def generate_param_string(param: APIParameter) -> str;
+}
+
+"""Handler for BODY parameters without files (JSON)."""
+obj JSONBodyParameterHandler(ParameterHandler) {
+    has body_params: list[APIParameter];
+
+    """Generate Pydantic model for JSON body."""
+    def generate_body_model -> (type[BaseModel] | None);
+}
+
+"""
+JFastApiServer: FastAPI implementation of JServer for programmatic endpoint creation.
+
+JFastApiServer provides FastAPI-specific implementation of the JServer interface,
+handling endpoint registration with FastAPI applications.
+
+This class implements the JServer interface by:
+- Storing registered endpoints internally
+- Implementing HTTP method handlers (_get, _post, _put, _patch, _delete)
+- Providing FastAPI app instance for server execution
+
+    Example:
+        >>> # Create server with endpoints
+        >>> endpoints = [
+        ...     JEndPoint(HTTPMethod.GET, "/users", get_users_callback),
+        ...     JEndPoint(HTTPMethod.POST, "/users", create_user_callback)
+        ... ]
+        >>> server = JFastApiServer(endpoints)
+        >>>
+        >>> # Execute to create FastAPI routes
+        >>> server.execute()
+        >>> app = server.create_server()
+
+    Attributes:
+        app (FastAPI): The underlying FastAPI application instance
+"""
+class JFastApiServer(JServer[FastAPI]) {
+    def init(
+        self: JFastApiServer,
+        endpoints: (list[JEndPoint] | None) = None,
+        app: (FastAPI | None) = None
+    ) -> None;
+
+    def _get(self: JFastApiServer, endpoint: JEndPoint) -> 'JFastApiServer';
+    def _post(self: JFastApiServer, endpoint: JEndPoint) -> 'JFastApiServer';
+    def _put(self: JFastApiServer, endpoint: JEndPoint) -> 'JFastApiServer';
+    def _patch(self: JFastApiServer, endpoint: JEndPoint) -> 'JFastApiServer';
+    def _delete(self: JFastApiServer, endpoint: JEndPoint) -> 'JFastApiServer';
+    def _route_priority(
+        self: JFastApiServer, endpoint: JEndPoint
+    ) -> tuple[int, int, int, str];
+
+    def execute(self: JFastApiServer) -> None;
+    def create_server(self: JFastApiServer) -> FastAPI;
+    def _create_fastapi_route(
+        self: JFastApiServer, method: HTTPMethod, endpoint: JEndPoint
+    ) -> None;
+
+    def _get_default_status_code(self: JFastApiServer, method: HTTPMethod) -> int;
+    def _create_endpoint_function(
+        self: JFastApiServer,
+        callback: Callable[(..., Any)],
+        parameters: list[APIParameter],
+        dependencies: list[Any]
+    ) -> Callable[..., Any];
+
+    def _get_python_type(self: JFastApiServer, type_string: str) -> type[Any];
+    def _create_response_model(
+        self: JFastApiServer, response_config: (dict[(str, Any)] | None) = None
+    ) -> (type[BaseModel] | None);
+
+    def get_app(self: JFastApiServer) -> FastAPI;
+    def run_server(
+        self: JFastApiServer, host: str = '0.0.0.0', port: int = 8000
+    ) -> None;
+}

jac_scale/jserver/jserver.jac

@@ -0,0 +1,101 @@
+import from abc { ABC, abstractmethod }
+import from collections.abc { Callable }
+import from dataclasses { dataclass }
+import from typing { Any, Generic, TypeVar }
+import from pydantic { BaseModel }
+import from enum { StrEnum }
+
+glob T = TypeVar('T');
+
+class HTTPMethod(StrEnum) {
+    has GET: str = 'GET',
+        POST: str = 'POST',
+        PUT: str = 'PUT',
+        PATCH: str = 'PATCH',
+        DELETE: str = 'DELETE';
+}
+
+class ParameterType(StrEnum) {
+    has QUERY: str = 'query',
+        PATH: str = 'path',
+        BODY: str = 'body',
+        HEADER: str = 'header',
+        FILE: str = 'file';
+}
+
+obj APIParameter {
+    has name: str,
+        <>type: ParameterType = ParameterType.QUERY,
+        data_type: str = 'str',
+        required: bool = True,
+        <>default: Any = None,
+        description: str = '';
+}
+
+"""
+Data class representing a single API endpoint.
+This class provides a clean representation of an endpoint configuration,
+including its method, path, callback function, parameters, and response model.
+
+Attributes:
+    method (HTTPMethod): The HTTP method for the endpoint (GET, POST, etc.)
+    path (str): The URL path for the endpoint
+    callback (Callable): The function to be called when the endpoint is accessed
+    parameters (list[APIParameter] | None): List of parameters for the endpoint
+    response_model (type[BaseModel] | None): Pydantic model for the response
+    tags (list[str] | None): Tags for categorizing the endpoint
+    summary (str | None): Short summary of the endpoint
+    description (str | None): Detailed description of the endpoint
+"""
+obj JEndPoint {
+    has method: HTTPMethod,
+        path: str,
+        callback: Callable[(..., Any)],
+        parameters: (list[APIParameter] | None) = None,
+        response_model: (type[BaseModel] | None) = None,
+        tags: (list[str] | None) = None,
+        summary: (str | None) = None,
+        description: (str | None) = None;
+}
+
+"""Abstract base class for server implementations."""
+class JServer(ABC, Generic[T]) {
+    def init(self: JServer, end_points: list[JEndPoint]) -> None;
+    def get_endpoints(self: JServer) -> list[JEndPoint];
+    def add_endpoint(self: JServer, endpoint: JEndPoint) -> None;
+    def execute(self: JServer) -> None;
+    @abstractmethod
+    def _get(self: JServer, endpoint: JEndPoint) -> 'JServer[T]';
+
+    @abstractmethod
+    def _post(self: JServer, endpoint: JEndPoint) -> 'JServer[T]';
+
+    @abstractmethod
+    def _put(self: JServer, endpoint: JEndPoint) -> 'JServer[T]';
+
+    @abstractmethod
+    def _patch(self: JServer, endpoint: JEndPoint) -> 'JServer[T]';
+
+    @abstractmethod
+    def _delete(self: JServer, endpoint: JEndPoint) -> 'JServer[T]';
+
+    """
+    Create a complete server with all endpoints registered.
+
+    This is a convenience method that gets all endpoints and executes them
+    to create a fully configured server. The return type depends on the
+    concrete implementation.
+
+    Args:
+        app (Optional[FastAPI]): Optional FastAPI instance to use (ignored in base implementation)
+
+    Returns:
+        Any: Implementation-specific configured server
+    """
+    @abstractmethod
+    def create_server(self: JServer) -> T { }
+
+    """Run the server on the specified host and port."""
+    @abstractmethod
+    def run_server(self: JServer, host: str = 'localhost', port: int = 8000) -> None { }
+}

jac_scale/memory_hierarchy.jac

@@ -0,0 +1,138 @@
+"""
+Memory Hierarchy Implementation for jac-scale.
+
+This module provides scalable storage backends that replace the default
+implementations in jaclang.runtimelib.memory:
+- RedisBackend: Replaces LocalCacheMemory as L2 distributed cache
+- MongoBackend: Replaces SqliteMemory as L3 persistent storage
+
+ScaleTieredMemory extends TieredMemory by swapping in these backends.
+Falls back to jaclang's SqliteMemory when MongoDB is unavailable.
+"""
+import logging;
+import from collections.abc { Callable, Generator, Iterable }
+import from pickle { dumps, loads }
+import from typing { Any }
+import from uuid { UUID }
+import redis;
+import from pymongo { MongoClient }
+import from pymongo.errors { ConnectionFailure }
+import from jaclang.pycore.archetype { Anchor, NodeAnchor, Root }
+import from jaclang.runtimelib.memory {
+    CacheMemory,
+    PersistentMemory,
+    TieredMemory,
+    SqliteMemory
+}
+import from jaclang.runtimelib.utils { storage_key, to_uuid }
+import from jac_scale.config_loader { get_scale_config }
+
+# Load database configuration from jac.toml with env var overrides
+glob _db_config = get_scale_config().get_database_config(),
+     logger = logging.getLogger(__name__);
+
+"""
+Redis cache backend - implements CacheMemory for distributed L2 caching.
+Replaces LocalCacheMemory when Redis is available.
+"""
+obj RedisBackend(CacheMemory) {
+    has redis_url: str = _db_config['redis_url'],
+        redis_client: (redis.Redis | None) = None;
+
+    def postinit -> None;
+    def is_available -> bool;
+    # CacheMemory interface (Memory methods + cache-specific)
+    def get(id: UUID) -> (Anchor | None);
+    def put(anchor: Anchor) -> None;
+    def delete(id: UUID) -> None;
+    def close -> None;
+    def has(id: UUID) -> bool;
+    def query(
+        filter: (Callable[[Anchor], bool] | None) = None
+    ) -> Generator[Anchor, None, None];
+
+    def get_roots -> Generator[Root, None, None];
+    def find(
+        ids: (UUID | Iterable[UUID]),
+        filter: (Callable[[Anchor], Anchor] | None) = None
+    ) -> Generator[Anchor, None, None];
+
+    def find_one(
+        ids: (UUID | Iterable[UUID]),
+        filter: (Callable[[Anchor], Anchor] | None) = None
+    ) -> (Anchor | None);
+
+    def commit(anchor: (Anchor | None) = None) -> None;
+    # CacheMemory-specific
+    def exists(id: UUID) -> bool;
+    def put_if_exists(anchor: Anchor) -> bool;
+    def invalidate(id: UUID) -> None;
+}
+
+"""
+MongoDB persistence backend - implements PersistentMemory for durable L3 storage.
+Replaces SqliteMemory when MongoDB is available.
+"""
+obj MongoBackend(PersistentMemory) {
+    has client: (MongoClient | None) = None,
+        db_name: str = 'jac_db',
+        collection_name: str = 'anchors',
+        mongo_url: str = _db_config['mongodb_uri'];
+
+    def postinit -> None;
+    def is_available -> bool;
+    # PersistentMemory interface (Memory methods + persistence-specific)
+    def get(id: UUID) -> (Anchor | None);
+    def put(anchor: Anchor) -> None;
+    def delete(id: UUID) -> None;
+    def close -> None;
+    def has(id: UUID) -> bool;
+    def query(
+        filter: (Callable[[Anchor], bool] | None) = None
+    ) -> Generator[Anchor, None, None];
+
+    def get_roots -> Generator[Root, None, None];
+    def find(
+        ids: (UUID | Iterable[UUID]),
+        filter: (Callable[[Anchor], Anchor] | None) = None
+    ) -> Generator[Anchor, None, None];
+
+    def find_one(
+        ids: (UUID | Iterable[UUID]),
+        filter: (Callable[[Anchor], Anchor] | None) = None
+    ) -> (Anchor | None);
+
+    def commit(anchor: (Anchor | None) = None) -> None;
+    # PersistentMemory-specific
+    def sync -> None;
+    def bulk_put(anchors: Iterable[Anchor]) -> None;
+    # Internal
+    def _load_anchor(raw: dict[(str, Any)]) -> (Anchor | None);
+}
+
+"""
+Persistence backend type for ScaleTieredMemory.
+"""
+enum PersistenceType {
+    NONE,
+    MONGODB,
+    SQLITE
+}
+
+"""
+Scalable Tiered Memory - extends TieredMemory with distributed backends.
+
+Swaps the default implementations:
+- L2: RedisBackend instead of LocalCacheMemory (when Redis available)
+- L3: MongoBackend instead of SqliteMemory (when MongoDB available)
+
+Falls back to jaclang's SqliteMemory for L3 when MongoDB is unavailable.
+Storage configuration comes from environment variables or jac.toml.
+"""
+obj ScaleTieredMemory(TieredMemory) {
+    has _cache_available: bool = False,
+        _persistence_type: PersistenceType = PersistenceType.NONE;
+
+    def init(use_cache: bool = True) -> None;
+    def close -> None;
+}

jac_scale/plugin.jac

@@ -0,0 +1,218 @@
+"""File covering plugin implementation."""
+import os;
+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.pycore.runtime { hookimpl, plugin_manager }
+import from jaclang.runtimelib.context { ExecutionContext }
+import from jaclang.runtimelib.server { JacAPIServer as JacServer }
+import from .context { JScaleExecutionContext }
+import from .serve { JacAPIServer }
+import from .jserver.jfast_api { JFastApiServer }
+import from .config_loader { get_scale_config }
+import from .factories.deployment_factory { DeploymentTargetFactory }
+import from .factories.registry_factory { ImageRegistryFactory }
+import from .factories.utility_factory { UtilityFactory }
+import from .abstractions.config.app_config { AppConfig }
+
+"""Pre-hook for jac start command to handle --scale flag."""
+def _scale_pre_hook(context: HookContext) -> None {
+    scale = context.get_arg("scale", False);
+    if scale {
+        # Handle deployment instead of local server
+        filename = context.get_arg("filename");
+        build = context.get_arg("build", False);
+        target = context.get_arg("target", "kubernetes");
+        registry = context.get_arg("registry", "dockerhub");
+        if not os.path.exists(filename) {
+            raise FileNotFoundError(f"File not found: '{filename}'") ;
+        }
+        code_folder = os.path.dirname(filename) or '.';
+        dotenv_path = os.path.join(code_folder, '.env');
+        load_dotenv(dotenv_path);
+        code_folder = os.path.relpath(code_folder);
+        code_folder = pathlib.Path(code_folder).as_posix();
+        base_file_path = os.path.basename(filename);
+        # Get configuration
+        scale_config = get_scale_config();
+        # Create logger
+        logger = UtilityFactory.create_logger('standard');
+        # Get target-specific config
+        if target == 'kubernetes' {
+            target_config = scale_config.get_kubernetes_config();
+        } else {
+            # For future targets, get from config
+            target_config = scale_config.get_kubernetes_config();  # Default for now
+        }
+        # Create deployment target
+        deployment_target = DeploymentTargetFactory.create(
+            target, target_config, logger
+        );
+        # Handle image registry if build is requested
+        if build {
+            # Use target config for registry (it contains docker credentials)
+            image_registry = ImageRegistryFactory.create(registry, target_config);
+            deployment_target.image_registry = image_registry;
+        }
+        # Create app config
+        app_config = AppConfig(
+            code_folder=code_folder, file_name=base_file_path, build=build
+        );
+        # 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}");
+        }
+        # Cancel normal start execution since we handled it
+        context.set_data("cancel_execution", True);
+        context.set_data("cancel_return_code", 0);
+    }
+}
+
+"""Jac CLI."""
+class JacCmd {
+    """Create Jac CLI cmds."""
+    @hookimpl
+    static def create_cmd -> None {
+        """Jac Scale functionality.""";
+        registry = get_registry();
+
+        # Extend jac start with --scale and related flags
+        registry.extend_command(
+            "start",
+            args=[
+                Arg.create(
+                    "scale",
+                    typ=bool,
+                    default=False,
+                    help="Deploy to a target platform instead of running locally",
+                    short=""  # Disable auto-generated -s (conflicts with --session)
+                ),
+                Arg.create(
+                    "build",
+                    typ=bool,
+                    default=False,
+                    help="Build and push Docker image (with --scale)",
+                    short="b"
+                ),
+                Arg.create(
+                    "target",
+                    typ=str,
+                    default="kubernetes",
+                    help="Deployment target (kubernetes, aws, gcp, etc.)",
+                ),
+                Arg.create(
+                    "registry",
+                    typ=str,
+                    default="dockerhub",
+                    help="Image registry (dockerhub, ecr, gcr, etc.)",
+                ),
+
+            ],
+            pre_hook=_scale_pre_hook,
+            source="jac-scale"
+        );
+
+        @registry.command(
+            name="destroy",
+            help="Remove deployment from target platform",
+            args=[
+                Arg.create(
+                    "file_path", kind=ArgKind.POSITIONAL, help="Path to .jac file"
+                ),
+                Arg.create(
+                    "target",
+                    typ=str,
+                    default="kubernetes",
+                    help="Deployment target (kubernetes, aws, gcp, etc.)",
+                ),
+
+            ],
+            examples=[("jac destroy app.jac", "Remove deployment for app"), ],
+            group="deployment",
+            priority=CommandPriority.PLUGIN,
+            source="jac-scale"
+        )
+        def destroy(file_path: str, target: str = "kubernetes") -> int {
+            if not os.path.exists(file_path) {
+                raise FileNotFoundError(f"File not found: '{file_path}'") ;
+            }
+            code_folder = os.path.dirname(file_path) or '.';
+            dotenv_path = os.path.join(code_folder, '.env');
+            load_dotenv(dotenv_path);
+
+            # Get configuration
+            scale_config = get_scale_config();
+
+            # Create logger
+            logger = UtilityFactory.create_logger('standard');
+
+            # Get target-specific config
+            if target == 'kubernetes' {
+                target_config = scale_config.get_kubernetes_config();
+            } else {
+                # For future targets, get from config
+                target_config = scale_config.get_kubernetes_config();  # Default for now
+            }
+
+            # Create deployment target and destroy
+            deployment_target = DeploymentTargetFactory.create(
+                target, target_config, logger
+            );
+            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}");
+            return 0;
+        }
+    }
+}
+
+"""Jac Scale Plugin Implementation."""
+class JacScalePlugin {
+    @hookimpl
+    static def create_j_context(user_root: (str | None)) -> ExecutionContext {
+        # Storage backend configured via environment (MONGODB_URI, etc.)
+        ctx = JScaleExecutionContext();
+        if user_root is not None {
+            ctx.set_user_root(user_root);
+        }
+        return ctx;
+    }
+
+    """Create the API server instance."""
+    @hookimpl
+    static def create_server(
+        jac_server: JacServer, host: str, port: int
+    ) -> JFastApiServer {
+        return JFastApiServer([]);
+    }
+
+    """Provide jac-scale's enhanced JacAPIServer class."""
+    @hookimpl
+    static def get_api_server_class -> type {
+        return JacAPIServer;
+    }
+}
+
+# Pluggy's varnames() puts parameters with defaults into kwargnames, not argnames.
+# But _multicall only passes argnames to hook implementations.
+# JacRuntimeInterfaceImpl strips defaults via generate_plugin_helpers, so we must too.
+import inspect;
+glob func = JacScalePlugin.create_j_context,
+     sig = inspect.signature(func),
+     sig_nodef = sig.replace(
+         parameters=[
+             p.replace(default=inspect.Parameter.empty)
+             for p in sig.parameters.values()
+         ]
+     );
+
+with entry {
+    func.__signature__ = sig_nodef;
+    plugin_manager.register(JacScalePlugin());
+}