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

jac_scale/tests/test_storage.py

@@ -0,0 +1,274 @@
+"""Tests for the storage abstraction."""
+
+import io
+import os
+import shutil
+import tempfile
+from collections.abc import Generator
+from pathlib import Path
+
+import pytest
+
+try:
+    from jaclang.runtimelib.storage import LocalStorage  # type: ignore[attr-defined]
+except ImportError as e:
+    pytest.skip(f"Jac modules not compiled: {e}", allow_module_level=True)
+
+
+@pytest.fixture
+def temp_storage_dir() -> Generator[str, None, None]:
+    """Create a temporary directory for storage tests."""
+    temp_dir = tempfile.mkdtemp()
+    yield temp_dir
+    if os.path.exists(temp_dir):
+        shutil.rmtree(temp_dir)
+
+
+@pytest.fixture
+def local_storage(temp_storage_dir: str) -> Generator[LocalStorage, None, None]:
+    """Create a LocalStorage instance with temp directory."""
+    storage = LocalStorage(base_path=temp_storage_dir)
+    yield storage
+
+
+class TestLocalStorage:
+    """Tests for LocalStorage implementation."""
+
+    def test_upload_from_file_path(
+        self, local_storage: LocalStorage, temp_storage_dir: str
+    ) -> None:
+        """Test uploading a file from a file path."""
+        source_file = Path(temp_storage_dir) / "source.txt"
+        source_file.write_text("Hello, World!")
+
+        result = local_storage.upload(str(source_file), "uploaded/file.txt")
+
+        assert local_storage.exists("uploaded/file.txt")
+        assert Path(result).exists()
+
+    def test_upload_from_file_object(self, local_storage: LocalStorage) -> None:
+        """Test uploading from a file-like object."""
+        file_obj = io.BytesIO(b"Binary content here")
+
+        local_storage.upload(file_obj, "binary/data.bin")
+
+        assert local_storage.exists("binary/data.bin")
+        content = local_storage.download("binary/data.bin")
+        assert content == b"Binary content here"
+
+    def test_download_returns_bytes(self, local_storage: LocalStorage) -> None:
+        """Test download returns bytes when no destination specified."""
+        file_obj = io.BytesIO(b"Test content")
+        local_storage.upload(file_obj, "test.txt")
+
+        content = local_storage.download("test.txt")
+
+        assert content == b"Test content"
+
+    def test_download_to_file_path(
+        self, local_storage: LocalStorage, temp_storage_dir: str
+    ) -> None:
+        """Test download to a file path."""
+        file_obj = io.BytesIO(b"Download me")
+        local_storage.upload(file_obj, "source.txt")
+        dest_path = Path(temp_storage_dir) / "downloaded.txt"
+
+        local_storage.download("source.txt", str(dest_path))
+
+        assert dest_path.exists()
+        assert dest_path.read_bytes() == b"Download me"
+
+    def test_download_to_file_object(self, local_storage: LocalStorage) -> None:
+        """Test download to a file-like object."""
+        file_obj = io.BytesIO(b"Stream me")
+        local_storage.upload(file_obj, "stream.txt")
+        output = io.BytesIO()
+
+        local_storage.download("stream.txt", output)
+
+        output.seek(0)
+        assert output.read() == b"Stream me"
+
+    def test_download_nonexistent_file_raises(
+        self, local_storage: LocalStorage
+    ) -> None:
+        """Test that downloading a non-existent file raises FileNotFoundError."""
+        with pytest.raises(FileNotFoundError):
+            local_storage.download("nonexistent.txt")
+
+    def test_delete_existing_file(self, local_storage: LocalStorage) -> None:
+        """Test deleting an existing file."""
+        file_obj = io.BytesIO(b"Delete me")
+        local_storage.upload(file_obj, "to_delete.txt")
+        assert local_storage.exists("to_delete.txt")
+
+        result = local_storage.delete("to_delete.txt")
+
+        assert result is True
+        assert not local_storage.exists("to_delete.txt")
+
+    def test_delete_nonexistent_file(self, local_storage: LocalStorage) -> None:
+        """Test deleting a non-existent file returns False."""
+        result = local_storage.delete("nonexistent.txt")
+
+        assert result is False
+
+    def test_exists_returns_true_for_existing(
+        self, local_storage: LocalStorage
+    ) -> None:
+        """Test exists returns True for existing file."""
+        file_obj = io.BytesIO(b"I exist")
+        local_storage.upload(file_obj, "exists.txt")
+
+        assert local_storage.exists("exists.txt") is True
+
+    def test_exists_returns_false_for_nonexistent(
+        self, local_storage: LocalStorage
+    ) -> None:
+        """Test exists returns False for non-existent file."""
+        assert local_storage.exists("nonexistent.txt") is False
+
+    def test_list_files_non_recursive(self, local_storage: LocalStorage) -> None:
+        """Test listing files non-recursively."""
+        local_storage.upload(io.BytesIO(b"1"), "folder/file1.txt")
+        local_storage.upload(io.BytesIO(b"2"), "folder/file2.txt")
+        local_storage.upload(io.BytesIO(b"3"), "folder/sub/file3.txt")
+
+        files = list(local_storage.list_files("folder", recursive=False))
+
+        # Should include file1, file2, and sub directory
+        assert len(files) == 3
+
+    def test_list_files_recursive(self, local_storage: LocalStorage) -> None:
+        """Test listing files recursively."""
+        local_storage.upload(io.BytesIO(b"1"), "folder/file1.txt")
+        local_storage.upload(io.BytesIO(b"2"), "folder/file2.txt")
+        local_storage.upload(io.BytesIO(b"3"), "folder/sub/file3.txt")
+
+        files = list(local_storage.list_files("folder", recursive=True))
+
+        # Should only include files (not directories) recursively
+        assert len(files) == 3
+        assert any("file1.txt" in f for f in files)
+        assert any("file2.txt" in f for f in files)
+        assert any("file3.txt" in f for f in files)
+
+    def test_get_metadata(self, local_storage: LocalStorage) -> None:
+        """Test getting file metadata."""
+        content = b"Metadata test content"
+        local_storage.upload(io.BytesIO(content), "meta.txt")
+
+        metadata = local_storage.get_metadata("meta.txt")
+
+        assert metadata["size"] == len(content)
+        assert "modified" in metadata
+        assert "created" in metadata
+        assert metadata["is_dir"] is False
+        assert metadata["name"] == "meta.txt"
+
+    def test_get_metadata_nonexistent_raises(self, local_storage: LocalStorage) -> None:
+        """Test that getting metadata of non-existent file raises error."""
+        with pytest.raises(FileNotFoundError):
+            local_storage.get_metadata("nonexistent.txt")
+
+    def test_copy_file(self, local_storage: LocalStorage) -> None:
+        """Test copying a file."""
+        local_storage.upload(io.BytesIO(b"Copy me"), "original.txt")
+
+        result = local_storage.copy("original.txt", "copied.txt")
+
+        assert result is True
+        assert local_storage.exists("original.txt")
+        assert local_storage.exists("copied.txt")
+        assert local_storage.download("copied.txt") == b"Copy me"
+
+    def test_copy_nonexistent_returns_false(self, local_storage: LocalStorage) -> None:
+        """Test copying non-existent file returns False."""
+        result = local_storage.copy("nonexistent.txt", "dest.txt")
+
+        assert result is False
+
+    def test_move_file(self, local_storage: LocalStorage) -> None:
+        """Test moving a file."""
+        local_storage.upload(io.BytesIO(b"Move me"), "to_move.txt")
+
+        result = local_storage.move("to_move.txt", "moved.txt")
+
+        assert result is True
+        assert not local_storage.exists("to_move.txt")
+        assert local_storage.exists("moved.txt")
+        assert local_storage.download("moved.txt") == b"Move me"
+
+    def test_move_nonexistent_returns_false(self, local_storage: LocalStorage) -> None:
+        """Test moving non-existent file returns False."""
+        result = local_storage.move("nonexistent.txt", "dest.txt")
+
+        assert result is False
+
+    def test_creates_directories_automatically(self, temp_storage_dir: str) -> None:
+        """Test that directories are created when create_dirs is True."""
+        new_path = os.path.join(temp_storage_dir, "new", "nested", "dir")
+        LocalStorage(base_path=new_path, create_dirs=True)
+
+        assert os.path.exists(new_path)
+
+    def test_upload_creates_parent_directories(
+        self, local_storage: LocalStorage
+    ) -> None:
+        """Test that upload creates parent directories as needed."""
+        file_obj = io.BytesIO(b"Nested content")
+
+        local_storage.upload(file_obj, "deep/nested/folder/file.txt")
+
+        assert local_storage.exists("deep/nested/folder/file.txt")
+
+
+class TestStorageIntegration:
+    """Integration tests for storage operations."""
+
+    def test_full_file_lifecycle(self, local_storage: LocalStorage) -> None:
+        """Test complete file lifecycle: upload, read, copy, move, delete."""
+        # Upload
+        content = b"Lifecycle test content"
+        local_storage.upload(io.BytesIO(content), "lifecycle.txt")
+        assert local_storage.exists("lifecycle.txt")
+
+        # Read
+        downloaded = local_storage.download("lifecycle.txt")
+        assert downloaded == content
+
+        # Copy
+        local_storage.copy("lifecycle.txt", "lifecycle_copy.txt")
+        assert local_storage.exists("lifecycle_copy.txt")
+
+        # Move
+        local_storage.move("lifecycle_copy.txt", "lifecycle_moved.txt")
+        assert not local_storage.exists("lifecycle_copy.txt")
+        assert local_storage.exists("lifecycle_moved.txt")
+
+        # Delete
+        local_storage.delete("lifecycle.txt")
+        local_storage.delete("lifecycle_moved.txt")
+        assert not local_storage.exists("lifecycle.txt")
+        assert not local_storage.exists("lifecycle_moved.txt")
+
+    def test_upload_large_file(self, local_storage: LocalStorage) -> None:
+        """Test uploading a larger file (1MB)."""
+        large_content = b"x" * (1024 * 1024)  # 1MB
+        file_obj = io.BytesIO(large_content)
+
+        local_storage.upload(file_obj, "large_file.bin")
+
+        metadata = local_storage.get_metadata("large_file.bin")
+        assert metadata["size"] == 1024 * 1024
+
+        downloaded = local_storage.download("large_file.bin")
+        assert downloaded == large_content
+
+    def test_special_characters_in_filename(self, local_storage: LocalStorage) -> None:
+        """Test handling files with special characters in name."""
+        content = b"Special chars"
+        local_storage.upload(io.BytesIO(content), "file-with_special.chars.txt")
+
+        assert local_storage.exists("file-with_special.chars.txt")
+        assert local_storage.download("file-with_special.chars.txt") == content

jac_scale/user_manager.jac

@@ -0,0 +1,49 @@
+import jwt;
+import from datetime { UTC, datetime, timedelta }
+import from typing { Any }
+import from fastapi { Request, Response }
+import from jaclang.runtimelib.server { UserManager }
+import from jaclang.runtimelib.transport { TransportResponse, Meta }
+import from jac_scale.serve { Platforms, Operations }
+import from jac_scale.utils { generate_random_password }
+import from jac_scale.config_loader { get_scale_config }
+import from jac_scale.sso_provider { SSOProvider, SSOUserInfo }
+import from jac_scale.google_sso_provider { GoogleSSOProvider }
+
+# Load configuration
+glob _jwt_config = get_scale_config().get_jwt_config(),
+     _sso_config = get_scale_config().get_sso_config(),
+     JWT_SECRET = _jwt_config['secret'],
+     JWT_ALGORITHM = _jwt_config['algorithm'],
+     JWT_EXP_DELTA_DAYS = _jwt_config['exp_delta_days'],
+     SSO_HOST = _sso_config['host'];
+
+obj JacScaleUserManager(UserManager) {
+    has SUPPORTED_PLATFORMS: dict = {};
+
+    def postinit -> None;
+    # JWT methods
+    def create_jwt_token(username: str) -> str;
+    def validate_jwt_token(token: str) -> (str | None);
+    def refresh_jwt_token(token: str) -> (str | None);
+    # SSO methods
+    def get_sso(platform: str, operation: str) -> (SSOProvider | None);
+    async def sso_initiate(
+        platform: str, operation: str
+    ) -> (Response | TransportResponse);
+
+    async def sso_callback(
+        request: Request, platform: str, operation: str
+    ) -> TransportResponse;
+
+    # SSO Account Linking methods
+    def link_sso_account(
+        user_id: str, platform: str, external_id: str, email: str
+    ) -> dict[str, str];
+
+    def unlink_sso_account(user_id: str, platform: str) -> dict[str, str];
+    def get_sso_accounts(user_id: str) -> list[dict[str, str]];
+    def get_user_by_sso(platform: str, external_id: str) -> (dict[str, str] | None);
+    # Override validate_token to use JWT
+    def validate_token(token: str) -> (str | None);
+}

jac_scale/webhook.jac

@@ -0,0 +1,93 @@
+"""Webhook support for Jac Scale.
+
+This module provides webhook-related functionality including:
+- API key generation and management
+- HMAC-SHA256 signature verification for webhook security
+- Webhook configuration and utilities
+
+API keys are generated per-user and can be used to authenticate webhook calls.
+The API key is wrapped in a JWT for secure storage and validation.
+"""
+import hmac;
+import hashlib;
+import secrets;
+import jwt;
+import from datetime { UTC, datetime, timedelta }
+import from typing { Any }
+import from pydantic { BaseModel, Field }
+import from jaclang.runtimelib.transport { TransportResponse, Meta }
+import from jac_scale.config_loader { get_scale_config }
+
+# Load webhook configuration
+glob _webhook_config = get_scale_config().get_webhook_config(),
+     WEBHOOK_SECRET = _webhook_config['secret'],
+     WEBHOOK_SIGNATURE_HEADER = _webhook_config['signature_header'],
+     WEBHOOK_VERIFY_SIGNATURE = _webhook_config['verify_signature'],
+     WEBHOOK_API_KEY_EXPIRY_DAYS = _webhook_config['api_key_expiry_days'];
+
+"""Pydantic model for API key creation request."""
+class CreateApiKeyRequest(BaseModel) {
+    has name: str = Field(..., description='A friendly name for the API key'),
+        expiry_days: int | None = Field(
+            None, description='Number of days until expiry (default from config)'
+        );
+}
+
+"""Pydantic model for API key response."""
+class ApiKeyResponse(BaseModel) {
+    has api_key: str = Field(..., description='The generated API key'),
+        api_key_id: str = Field(..., description='Unique identifier for the API key'),
+        name: str = Field(..., description='Friendly name for the API key'),
+        created_at: str = Field(..., description='ISO timestamp of creation'),
+        expires_at: str | None = Field(
+            None, description='ISO timestamp of expiry, or null if no expiry'
+        );
+}
+
+"""Webhook utilities for signature generation and verification."""
+obj WebhookUtils {
+    """Generate HMAC-SHA256 signature for webhook payload."""
+    static def generate_signature(payload: bytes, secret: str) -> str;
+
+    """Verify HMAC-SHA256 signature for webhook payload."""
+    static def verify_signature(payload: bytes, signature: str, secret: str) -> bool;
+
+    """Generate a new API key."""
+    static def generate_api_key -> str;
+
+    """Create a JWT-wrapped API key token.
+
+    The API key is embedded in a JWT for secure validation and expiry management."""
+    static def create_api_key_token(
+        api_key_id: str, username: str, name: str, expiry_days: int | None = None
+    ) -> str;
+
+    """Validate an API key token and extract user information."""
+    static def validate_api_key(api_key: str) -> dict[str, str] | None;
+
+    """Extract signature from request header value."""
+    static def extract_signature(header_value: str) -> str;
+}
+
+"""Manager for API keys associated with users."""
+obj ApiKeyManager {
+    has _api_keys: dict[str, dict[str, Any]] = {},  # api_key_id -> key info
+        _user_keys: dict[str, list[str]] = {};  # username -> list of api_key_ids
+
+    """Create a new API key for a user."""
+    def create_api_key(
+        username: str, name: str, expiry_days: int | None = None
+    ) -> TransportResponse;
+
+    """List all API keys for a user."""
+    def list_api_keys(username: str) -> TransportResponse;
+
+    """Revoke an API key."""
+    def revoke_api_key(username: str, api_key_id: str) -> TransportResponse;
+
+    """Validate an API key and return the associated username."""
+    def validate_api_key(api_key: str) -> str | None;
+
+    """Check if an API key ID exists and is not revoked."""
+    def is_key_active(api_key_id: str) -> bool;
+}

{jac_scale-0.1.1.dist-info → jac_scale-0.1.4.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: jac-scale
-Version: 0.1.1
+Version: 0.1.4
 Author-email: Jason Mars <jason@mars.ninja>
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
-Requires-Dist: jaclang>=0.9.10
+Requires-Dist: jaclang>=0.9.13
 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
@@ -12,7 +12,7 @@ Requires-Dist: pymongo<5.0.0,>=4.15.4
 Requires-Dist: redis<8.0.0,>=7.1.0
 Requires-Dist: fastapi<0.122.0,>=0.121.3
 Requires-Dist: uvicorn<0.39.0,>=0.38.0
-Requires-Dist: pyjwt
+Requires-Dist: pyjwt<2.11.0,>=2.10.1
 Requires-Dist: fastapi-sso<1.0.0,>=0.18.0
 Requires-Dist: python-multipart<1.0.0,>=0.0.21
 
@@ -43,6 +43,13 @@ Requires-Dist: python-multipart<1.0.0,>=0.0.21
 
 Whether you're developing locally with `jac start` or deploying to production with `jac start --scale`, you get the same powerful features with the flexibility to choose your deployment strategy.
 
+### 4. Single Sign-On (SSO) Support
+
+- **Google SSO**: Built-in support for Google Sign-In out of the box
+- **Extensible Architecture**: Easily add other providers (GitHub, Microsoft, etc.)
+- **Secure Authentication**: Integrated with JWT for secure session management
+- **User Management**: Automatic account creation and linking
+
 ## Prerequisites
 
 - kubenetes(K8s) installed
@@ -484,7 +491,7 @@ async walker FetchData {
 | `MONGODB_URI` | URL of MongoDB database | - |
 | `REDIS_URL` | URL of Redis database | - |
 | `JWT_EXP_DELTA_DAYS` | Number of days until JWT token expires | `7` |
-| `JWT_SECRET` | Secret key used for JWT token signing and verification | `'supersecretkey'` |
+| `JWT_SECRET` | Secret key used for JWT token signing and verification | `'supersecretkey_for_testing_only!'` |
 | `JWT_ALGORITHM` | Algorithm used for JWT token encoding/decoding | `'HS256'` |
 | `SSO_HOST` | SSO host URL | `'http://localhost:8000/sso'` |
 | `SSO_GOOGLE_CLIENT_ID` | Google OAuth client ID | - |

{jac_scale-0.1.1.dist-info → jac_scale-0.1.4.dist-info}/RECORD

@@ -1,57 +1,70 @@
 jac_scale/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jac_scale/config_loader.jac,sha256=oOOOFcFfEP89Y3A-AI4cLqrEaO6g0jJqZglBsCoKM84,1222
-jac_scale/context.jac,sha256=Ezq5-9q2rBGhs5TTwYrVkFJ4nJN3e_Sgv0wM4eT9Qmc,479
-jac_scale/memory_hierarchy.jac,sha256=GFaLQNLMqHvS5anYNWD_TcsW8iAYIMk-7gNzWcoBGpU,4469
-jac_scale/plugin.jac,sha256=6kx1gE6hYtcOHECAUwkLVQEceQF47EMpXU7EIeQLd4o,8047
-jac_scale/plugin_config.jac,sha256=yaXyP1nUSDtVrTBFGwa0_NDeVHNlbEP1zGSgioe-F5k,7230
-jac_scale/serve.jac,sha256=9ZLK4Xfu3DbmX50QE02EaNW8L5ekfuu2Br8rkdYrwwk,4775
+jac_scale/config_loader.jac,sha256=fG1dN9AS54bzNL5XvPHNS4oMw8kknZnlAZ7ByPT0APU,1298
+jac_scale/context.jac,sha256=SIqQineAlLHJV3yWtYkeTIfcnqS0Oj15n8CWVSIqwJ8,529
+jac_scale/google_sso_provider.jac,sha256=UUTDgQrBHXp0eqHxiw7v_VkQyFMMza0UDM6S4T5e4OM,2473
+jac_scale/memory_hierarchy.jac,sha256=GuydhwujsH71TAkxeJ6Wfutp4v6GjDj23vGMreRj4yg,4533
+jac_scale/plugin.jac,sha256=E1Ou_sQ8RV35emY9-gM295Uu-Eg4w4qSEJYm3TTYsWY,9585
+jac_scale/plugin_config.jac,sha256=6_cTMzjDhr-7fGh2RMM5LCfjXlfKduGyFs0S0PnHKXQ,8718
+jac_scale/serve.jac,sha256=8xMOHX3X-sJFx6yENolL-7VM7Km1Mg5BPkUtMLUl9O4,5546
+jac_scale/sso_provider.jac,sha256=Kky8cxm5gR2Sbg-CFrWTILKSZrV6Ju-DCEgfG4Akxb8,2092
+jac_scale/user_manager.jac,sha256=UBApt_znhVEyxtfAdJ9sp_gslkHel4GGwXCBcNen_as,1932
 jac_scale/utils.jac,sha256=zpxA08_NlDDSd1oVlbknQ_UOwHWGBbhzjmT_u6UYN04,491
+jac_scale/webhook.jac,sha256=lTpevPoe-CEcj0-MAd8c1fHK7jGUL3YnN4_ouMeq4Ic,3660
 jac_scale/abstractions/database_provider.jac,sha256=NZbFmcESulYsmG-27f8GY9nxVs3JflGIEb3aDDOIPu0,1454
 jac_scale/abstractions/deployment_target.jac,sha256=5rJOd25FUXZZCNmDSUkyMljcXTAVJJDmelKw8WdPZm0,2071
 jac_scale/abstractions/image_registry.jac,sha256=UCOwwuts5e1emsdDIlHJOiyW2ePA7k7D8UJdzd2kN10,1386
 jac_scale/abstractions/logger.jac,sha256=YnXn8_jCpZ0IOBkJ7bFBMqo6WXO6BaDNVBqPq0lHbjk,652
-jac_scale/abstractions/config/app_config.jac,sha256=XD-VtltmHaXPFdVWw6HRqLJjSTqxS4fwQFZTnbGoYSQ,798
+jac_scale/abstractions/config/app_config.jac,sha256=yxXlTOFRNBq5yFMgYm1LjEzobwxP_k2EG4zXcoHf688,912
 jac_scale/abstractions/config/base_config.jac,sha256=ePT-up-63QGu2Jifi_CpPhd7_V9cPcHkInqGKDFryC4,785
 jac_scale/abstractions/models/deployment_result.jac,sha256=3Mx8TVvL74AF8LLnhMbuCyHTTu-DXesYWMvht1HoGFs,704
 jac_scale/abstractions/models/resource_status.jac,sha256=H6I9ZF92ia56bNmHR9dLMGsaFG4BafGh4sY-YwVRPu0,1031
 jac_scale/factories/database_factory.jac,sha256=-8QfF1vDUqsdDKnldmayxvB-Z6DwQeNMOlo7HgTaouQ,1736
 jac_scale/factories/deployment_factory.jac,sha256=1pzQ2HkqpKaeoycbRxdZ05McgTLpgj5Y5hmKhFTm1AY,1673
 jac_scale/factories/registry_factory.jac,sha256=qWgwEH75EtjXGj3d9NGeg7D9Yx2S_RW9udlCFvOOCqU,1210
+jac_scale/factories/storage_factory.jac,sha256=FVlx-f1BOq6H1yLWXT7OLSG-ZCENvlBPNr0OwFdo-VU,2661
 jac_scale/factories/utility_factory.jac,sha256=64gMv_N_pFeq5E7z3gXrLIqeRGS_RGIF5eLT8RxNl_I,1262
-jac_scale/impl/config_loader.impl.jac,sha256=j8YngI4mdcBKCBtly-8vN0WYXDwzdhwZ6bmmMc9Kza4,4769
-jac_scale/impl/context.impl.jac,sha256=LU9R3318_eXOOgLcv2x76Cl6lxmxPlILDI7E9U3QzUU,1000
+jac_scale/impl/config_loader.impl.jac,sha256=gIcOowYuoMvpilRK6vhAGf5ULYttrkh19fB5zP7KTdI,5668
+jac_scale/impl/context.impl.jac,sha256=3M33iA9L2SCIMT0rQTvb8MkveNCuTEjc7rNknK4Hruk,1071
 jac_scale/impl/memory_hierarchy.main.impl.jac,sha256=Jc4Cy-5cy0TtK2uQ6rdYruxa0ZfZKSYgo3jOoXv4ER4,2339
 jac_scale/impl/memory_hierarchy.mongo.impl.jac,sha256=APh7YloOj7bWGtv6DTBm7ekX13w_fectbZiFY0btwWU,6626
 jac_scale/impl/memory_hierarchy.redis.impl.jac,sha256=x27TzeBI87vz72s7esQvFz8EPk3EfhVMNKU8sP4s2hk,4900
-jac_scale/impl/serve.impl.jac,sha256=zs3JgM3w7e-fSZjnICUEJ8gcli--9XkE5yHF6kQiowI,66860
+jac_scale/impl/serve.impl.jac,sha256=zzWAF0PukDMdKKFmiwP-cupxrCA8YtZ_leYY-Qzcnkc,85767
+jac_scale/impl/user_manager.impl.jac,sha256=7xGoLMweQuoVW-na7XbK3bctfUHaSEnT9nB7DLgSlgw,11817
+jac_scale/impl/webhook.impl.jac,sha256=87IZn9nfSaNXX9RYXVJRJEz-3xzznpC6RhVBoJJA2X8,7504
 jac_scale/jserver/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jac_scale/jserver/jfast_api.jac,sha256=Ez7EZ883TS9IIACzK8QMqTgVTtNoaOenbmwNKnekBuc,5561
 jac_scale/jserver/jserver.jac,sha256=8gWh22nX9Z5rJp3D1AxOSU8lBhoX4-kBZ0uvJPPNqX8,3356
-jac_scale/jserver/impl/jfast_api.impl.jac,sha256=fJZDFKbFYhpYqIcauPNPd5tpRHx_Xd1DXo49-vTSXQA,26766
+jac_scale/jserver/impl/jfast_api.impl.jac,sha256=bnxoReOOntQL0FHDgLSoaXtQRtCYOOEVWhq-lAXeqI0,26931
 jac_scale/jserver/impl/jserver.impl.jac,sha256=4NOzfys4WQmGt6vttTTh6By12hEJqdvOzCZyCBsUQKk,2224
 jac_scale/providers/database/kubernetes_mongo.jac,sha256=nP43b-ePR8XInhhk7gzdvJvOJMZcTZanm1VALdiCqXA,4952
 jac_scale/providers/database/kubernetes_redis.jac,sha256=qF9HkNLLgiymxiCXbmETbVVDs5Wqs1m4s3O6xFR7jRA,3778
 jac_scale/providers/registry/dockerhub.jac,sha256=7KlgQJGGUeDF7zP8-KNF8HTShB4td1946OtIdS57EHI,2282
-jac_scale/targets/kubernetes/kubernetes_config.jac,sha256=R0h6g9-z9_K9Z4FpO2-t6Wefc-y_aLtLb3YeqPNU30Y,9513
-jac_scale/targets/kubernetes/kubernetes_target.jac,sha256=Dv-uq_HyhQm8czdak2_u0BK1gJ0ohjaHNU8Pgtb1BUE,29928
+jac_scale/targets/kubernetes/kubernetes_config.jac,sha256=Xk3EjKTEjptlctD2C5cTYjgw9V8i8mfsO-jKAa2IZZs,9406
+jac_scale/targets/kubernetes/kubernetes_target.jac,sha256=itICKs_sA4jOs7_wrFgpj5QhupjKVXRSvkaJMBL6t9g,35523
 jac_scale/targets/kubernetes/utils/kubernetes_utils.impl.jac,sha256=CPSlFlhCE3qdzPWiPVa7KbHkL_h5Gle5ySvq7UkwR4k,15756
 jac_scale/targets/kubernetes/utils/kubernetes_utils.jac,sha256=Nr257oCyduodJbxkLJeNYphFzz9NxviFfW1Tpc5dQKk,2129
 jac_scale/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jac_scale/tests/conftest.py,sha256=uiS352_HVmMf7V6T0BZl-Kn8svkKbj3jhNr-hEKrcPw,820
 jac_scale/tests/test_abstractions.py,sha256=gb5ueNcUcxpq0U0r_nEize9v027gRR_XiZlCEooAW6U,2612
-jac_scale/tests/test_deploy_k8s.py,sha256=iV7q1hK7BMulV4H_Rg9VJ3NrFFoEFE2gVWyvK7Zl6HE,9104
-jac_scale/tests/test_examples.py,sha256=FlmVbrCJk0Jt_NTSExctSI5sNShqS5vWa0eMyek1itQ,16898
+jac_scale/tests/test_deploy_k8s.py,sha256=rX9kJohqTeaRch-KSruWYF8eUnPGtJ_p6zy0sPkBXIA,9164
+jac_scale/tests/test_examples.py,sha256=2xOTf0rBiT_9w92ku7k9Pfv4A7ohLZpZdpAH0VHM86E,24044
 jac_scale/tests/test_factories.py,sha256=cf1gLrBdK9q8SlHyocZqtixyPtO2dLlrgNYeX5-_RYM,5073
 jac_scale/tests/test_file_upload.py,sha256=JooF-9rgwOqtNkWRfvfHu4W5x-gzk91bHVi13J9mnNE,16595
+jac_scale/tests/test_hooks.py,sha256=TzikM6dd1uKg1G2L1MtgXYzzjY6YhrbAQXZah-TO33Y,1366
 jac_scale/tests/test_k8s_utils.py,sha256=Oqocwl4m2IFgM27Lgsi96WJeHS8hnx9WDOcxq9YkqJU,4613
 jac_scale/tests/test_memory_hierarchy.py,sha256=q_DsKyPIuQymab_sEtXojDW0GOyunRxZJsNTJDrGA7s,8324
-jac_scale/tests/test_serve.py,sha256=VhZdU75PDMH71DEMKWkfs2KTUW6mpK9ZzpWOglCpFEk,65119
-jac_scale/tests/test_sso.py,sha256=hFFvjbrgtO_5557XaEwZLjrrQsc4k4S3GPTroU2bwPA,26779
-jac_scale/tests/fixtures/test_api.jac,sha256=JBQUXb7l7M3cHGjcY7I9e6XhQyLQY7FKiC8z1Ei7Ve8,4109
+jac_scale/tests/test_restspec.py,sha256=fYNpQi7ZhV7KnSoJQ4xH1tJIQeayaeCvFS5GBLAZO1o,10853
+jac_scale/tests/test_serve.py,sha256=xKPjQJLdtWaCISlP3Kirf3A4i1Fxubej_h5oLklKSY8,81244
+jac_scale/tests/test_sso.py,sha256=9h2AUC9JBM74O6xfpyIcl98iXyZWcDIGdKRtlb_5uqo,28104
+jac_scale/tests/test_storage.py,sha256=Y7CIbKrH3OmJQlBeV9A965-7TtxL6nuZtfkfoeqIeS4,10514
+jac_scale/tests/fixtures/test_api.jac,sha256=aqfvy4wgc0qPTM9_NYvXUcpemNTSdwW0tp432sdHZI4,6680
+jac_scale/tests/fixtures/test_restspec.jac,sha256=oFqACGtuoGz1xsURAaeXrQe7hkMI-W8hL5IKFDTQHKU,2511
 jac_scale/tests/fixtures/todo_app.jac,sha256=beI6AiRutmXsXxuzU9nIZTE-AuoBBP-WqbRA2ux1pN4,1216
+jac_scale/tests/fixtures/scale-feats/main.jac,sha256=QN8Opodha9jLWdRGCASByIogePr1XKphgKjyE9Pp73c,4205
+jac_scale/tests/fixtures/scale-feats/components/Button.cl.jac,sha256=e8tvNzW_QikFJMSTcbkziKP69NF00DqQVxcjLPkAW-w,903
 jac_scale/utilities/loggers/standard_logger.jac,sha256=6XL5ETAOBwbsFCOp0VN_7TOnqcQDmbLZVzubA-JR3vA,1376
-jac_scale-0.1.1.dist-info/METADATA,sha256=I-nL8nlf_Bc45KaJLHgTji6ozrF9I-xNHg3drRXM-8g,20125
-jac_scale-0.1.1.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-jac_scale-0.1.1.dist-info/entry_points.txt,sha256=n-Wm8JEtGOqy_IY_kgIOi3-uYnuVK-iWsvKiLkxlG4E,105
-jac_scale-0.1.1.dist-info/top_level.txt,sha256=PpgR0R8z9qoFbSser2K20r5Is4K6TxVwguoN6LfTEKU,10
-jac_scale-0.1.1.dist-info/RECORD,,
+jac_scale-0.1.4.dist-info/METADATA,sha256=F_sIgqYZVaPGz7cPpx-Sc-EqI0cNX43nEkFWQiUjU5w,20491
+jac_scale-0.1.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+jac_scale-0.1.4.dist-info/entry_points.txt,sha256=n-Wm8JEtGOqy_IY_kgIOi3-uYnuVK-iWsvKiLkxlG4E,105
+jac_scale-0.1.4.dist-info/top_level.txt,sha256=PpgR0R8z9qoFbSser2K20r5Is4K6TxVwguoN6LfTEKU,10
+jac_scale-0.1.4.dist-info/RECORD,,

{jac_scale-0.1.1.dist-info → jac_scale-0.1.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any