amsdal_cli 0.0.1__py3-none-any.whl

amsdal_cli/commands/serve/filters/models_watch_filter.py

@@ -0,0 +1,6 @@
+from watchfiles.filters import DefaultFilter
+
+
+class ModelsWatchFilter(DefaultFilter):
+    def __init__(self) -> None:
+        super().__init__(ignore_dirs=['fixtures'])

amsdal_cli/commands/serve/filters/static_files_watch_filter.py

@@ -0,0 +1,21 @@
+import os
+from typing import TYPE_CHECKING
+
+from watchfiles.filters import DefaultFilter
+
+if TYPE_CHECKING:
+    from watchfiles.main import Change
+
+
+class StaticFilesWatchFilter(DefaultFilter):
+    def __init__(self) -> None:
+        self.static_directory_name = 'static'
+        super().__init__()
+
+    def __call__(self, change: 'Change', path: str) -> bool:
+        parts = path.lstrip(os.sep).split(os.sep)
+
+        if not any(p == self.static_directory_name for p in parts):
+            return False
+
+        return super().__call__(change, path)

amsdal_cli/commands/serve/services/supervisor.py

@@ -0,0 +1,373 @@
+import multiprocessing
+from dataclasses import dataclass
+from multiprocessing.context import SpawnProcess
+from pathlib import Path
+from time import sleep
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import TypeAlias
+
+from amsdal_data.table_schemas.manager import TableSchemasManager
+from amsdal_framework.configs.main import settings
+from amsdal_framework.errors import AmsdalRuntimeError
+from amsdal_framework.manager import AmsdalManager
+from amsdal_framework.schemas.manager import SchemaManager
+from amsdal_models.classes.manager import ClassManager
+from amsdal_server.server import start
+from amsdal_utils.classes.version_manager import ClassVersionManager
+from amsdal_utils.config.manager import AmsdalConfigManager
+from rich import print
+from watchfiles import run_process
+from watchfiles.filters import PythonFilter
+
+from amsdal_cli.commands.serve.filters.models_watch_filter import ModelsWatchFilter
+from amsdal_cli.commands.serve.filters.static_files_watch_filter import StaticFilesWatchFilter
+
+spawn_context = multiprocessing.get_context('spawn')
+
+START_SERVER_EVENT = 'start_server'
+STOP_SERVER_EVENT = 'stop_server'
+
+if TYPE_CHECKING:
+    QueueType: TypeAlias = multiprocessing.Queue[str]
+else:
+    QueueType: TypeAlias = multiprocessing.Queue
+
+
+@dataclass
+class ProcessState:
+    server: SpawnProcess | None = None
+    watch_models: SpawnProcess | None = None
+    watch_static_files: SpawnProcess | None = None
+    watch_fixtures: SpawnProcess | None = None
+    watch_transactions: SpawnProcess | None = None
+
+
+class Supervisor:
+    def __init__(
+        self,
+        app_source_path: Path,
+        output_path: Path,
+        config_path: Path,
+    ) -> None:
+        self._app_source_path: Path = app_source_path
+        self._output_path: Path = output_path
+        self._config_path: Path = config_path
+        self._process_state: ProcessState = ProcessState()
+        self._queue: QueueType = spawn_context.Queue()
+
+    def run(self) -> None:
+        try:
+            self.start()
+
+            while True:
+                sleep(0.1)
+        except (KeyboardInterrupt, Exception):
+            self.stop()
+
+    def start(self) -> None:
+        self._process_state.server = self._run_server(
+            self._queue,
+            self._output_path,
+            self._config_path,
+        )
+        self._process_state.watch_models = self._run_watch_models(
+            self._queue,
+            self._app_source_path,
+            self._output_path,
+            self._config_path,
+        )
+        self._process_state.watch_static_files = self._run_watch_static_files(
+            self._app_source_path,
+            self._output_path,
+            self._config_path,
+        )
+        self._process_state.watch_transactions = self._run_watch_transactions(
+            self._app_source_path,
+            self._output_path,
+            self._config_path,
+        )
+
+    def stop(self) -> None:
+        if self._process_state.server is not None and self._process_state.server.is_alive():
+            self._process_state.server.terminate()
+
+        if self._process_state.watch_models is not None and self._process_state.watch_models.is_alive():
+            self._process_state.watch_models.terminate()
+
+        if self._process_state.watch_static_files is not None and self._process_state.watch_static_files.is_alive():
+            self._process_state.watch_static_files.terminate()
+
+        if self._process_state.watch_transactions is not None and self._process_state.watch_transactions.is_alive():
+            self._process_state.watch_transactions.terminate()
+
+    def wait(self) -> None:
+        if self._process_state.server is not None and self._process_state.server.is_alive():
+            self._process_state.server.join()
+
+        if self._process_state.watch_models is not None and self._process_state.watch_models.is_alive():
+            self._process_state.watch_models.join()
+
+        if self._process_state.watch_static_files is not None and self._process_state.watch_static_files.is_alive():
+            self._process_state.watch_static_files.join()
+
+        if self._process_state.watch_transactions is not None and self._process_state.watch_transactions.is_alive():
+            self._process_state.watch_transactions.join()
+
+    @classmethod
+    def _run_server(
+        cls,
+        queue: QueueType,
+        output_path: Path,
+        config_path: Path,
+    ) -> SpawnProcess:
+        process = spawn_context.Process(
+            target=cls._check_and_serve,
+            kwargs={
+                'queue': queue,
+                'is_development_mode': False,
+                'output_path': output_path,
+                'config_path': config_path,
+            },
+        )
+        process.start()
+
+        return process
+
+    @classmethod
+    def _check_and_serve(
+        cls,
+        queue: QueueType,
+        *,
+        is_development_mode: bool,
+        output_path: Path,
+        config_path: Path,
+    ) -> None:
+        _server_process: SpawnProcess | None = None
+
+        try:
+            while True:
+                event = queue.get()
+                if event == STOP_SERVER_EVENT:
+                    if _server_process is not None and _server_process.is_alive():
+                        _server_process.terminate()
+                elif event == START_SERVER_EVENT:
+                    _server_process = spawn_context.Process(
+                        target=cls._serve,
+                        kwargs={
+                            'is_development_mode': is_development_mode,
+                            'output_path': output_path,
+                            'config_path': config_path,
+                        },
+                    )
+                    _server_process.start()
+        except KeyboardInterrupt:
+            if _server_process is not None and _server_process.is_alive():
+                _server_process.terminate()
+
+    @classmethod
+    def _run_watch_models(
+        cls,
+        queue: QueueType,
+        app_source_path: Path,
+        output_path: Path,
+        config_path: Path,
+    ) -> SpawnProcess:
+        process = spawn_context.Process(
+            target=cls._watch,
+            args=(
+                'ModelsWatch',
+                app_source_path / 'models',
+            ),
+            kwargs={
+                'target': cls._build_models_and_migrate,
+                'kwargs': {
+                    'queue': queue,
+                    'app_source_path': app_source_path,
+                    'output_path': output_path,
+                    'config_path': config_path,
+                },
+                'watch_filter': ModelsWatchFilter(),
+            },
+        )
+        process.start()
+
+        return process
+
+    @classmethod
+    def _run_watch_static_files(
+        cls,
+        app_source_path: Path,
+        output_path: Path,
+        config_path: Path,
+    ) -> SpawnProcess:
+        process = spawn_context.Process(
+            target=cls._watch,
+            args=(
+                'StaticFilesWatch',
+                app_source_path,
+            ),
+            kwargs={
+                'target': cls._build_static_files,
+                'kwargs': {
+                    'app_source_path': app_source_path,
+                    'output_path': output_path,
+                    'config_path': config_path,
+                },
+                'watch_filter': StaticFilesWatchFilter(),
+            },
+        )
+        process.start()
+
+        return process
+
+    @classmethod
+    def _run_watch_transactions(
+        cls,
+        app_source_path: Path,
+        output_path: Path,
+        config_path: Path,
+    ) -> SpawnProcess:
+        process = spawn_context.Process(
+            target=cls._watch,
+            args=(
+                'TransactionsWatch',
+                app_source_path / 'transactions',
+            ),
+            kwargs={
+                'target': cls._build_transactions_and_apply,
+                'kwargs': {
+                    'app_source_path': app_source_path,
+                    'output_path': output_path,
+                    'config_path': config_path,
+                },
+                'watch_filter': PythonFilter(),
+            },
+        )
+        process.start()
+
+        return process
+
+    @classmethod
+    def _serve(
+        cls,
+        output_path: Path,
+        config_path: Path,
+        **kwargs: Any,
+    ) -> None:
+        from amsdal_utils.lifecycle.consumer import LifecycleConsumer
+        from amsdal_utils.lifecycle.enum import LifecycleEvent
+        from amsdal_utils.lifecycle.producer import LifecycleProducer
+
+        cls._invalidate_amsdal_state()
+
+        class AmsdalInitConsumer(LifecycleConsumer):
+            def on_event(self, *args: Any, **kwargs: Any) -> None:  # noqa: ARG002
+                settings.override(APP_PATH=output_path)
+
+                config_manager = AmsdalConfigManager()
+                config_manager.load_config(config_path)
+
+                amsdal_manager = AmsdalManager()
+                amsdal_manager.setup()
+                amsdal_manager.authenticate()
+                amsdal_manager.init_class_versions()
+
+        LifecycleProducer.add_listener(LifecycleEvent.ON_SERVER_STARTUP, AmsdalInitConsumer)
+        start(**kwargs)
+
+    @classmethod
+    def _build_models_and_migrate(
+        cls,
+        queue: QueueType,
+        app_source_path: Path,
+        output_path: Path,
+        config_path: Path,
+    ) -> None:
+        queue.put(STOP_SERVER_EVENT)
+        cls._invalidate_amsdal_state()
+        settings.override(APP_PATH=output_path)
+
+        config_manager = AmsdalConfigManager()
+        config_manager.load_config(config_path)
+
+        amsdal_manager = AmsdalManager()
+        amsdal_manager.pre_setup()
+
+        print('[blue]Building models...[/blue]', end=' ')
+        amsdal_manager.build_models(app_source_path / 'models')
+        print('[green]OK![/green]')
+
+        print('[blue]Apply migrations...[/blue]')
+        amsdal_manager = AmsdalManager()
+        amsdal_manager.setup()
+        amsdal_manager.authenticate()
+        amsdal_manager.migrate()
+        print('[green]OK![/green]')
+
+        print('[blue]Building fixtures...[/blue]', end=' ')
+        amsdal_manager.build_fixtures(app_source_path / 'models')
+        print('[green]OK![/green]')
+
+        print('[blue]Applying fixtures...[/blue]', end=' ')
+        amsdal_manager.apply_fixtures()
+        print('[green]OK![/green]')
+
+        queue.put(START_SERVER_EVENT)
+
+    @staticmethod
+    def _invalidate_amsdal_state() -> None:
+        try:
+            amsdal_manager = AmsdalManager()
+            amsdal_manager.teardown()
+        except AmsdalRuntimeError:
+            ...
+
+        AmsdalManager.invalidate()
+        ClassManager.invalidate()
+        ClassVersionManager.invalidate()
+        SchemaManager.invalidate()
+        TableSchemasManager.invalidate()
+
+    @staticmethod
+    def _build_static_files(
+        app_source_path: Path,
+        output_path: Path,
+        config_path: Path,
+    ) -> None:
+        settings.override(APP_PATH=output_path)
+
+        config_manager = AmsdalConfigManager()
+        config_manager.load_config(config_path)
+
+        amsdal_manager = AmsdalManager()
+        amsdal_manager.pre_setup()
+
+        print('[blue]Building static files...[/blue]', end=' ')
+        amsdal_manager.build_static_files(app_source_path)
+        print('[green]OK![/green]')
+
+    @staticmethod
+    def _build_transactions_and_apply(
+        app_source_path: Path,
+        output_path: Path,
+        config_path: Path,
+    ) -> None:
+        settings.override(APP_PATH=output_path)
+
+        config_manager = AmsdalConfigManager()
+        config_manager.load_config(config_path)
+
+        amsdal_manager = AmsdalManager()
+        amsdal_manager.pre_setup()
+
+        print('[blue]Building transactions...[/blue]', end=' ')
+        amsdal_manager.build_transactions(app_source_path)
+        print('[green]OK![/green]')
+
+    @staticmethod
+    def _watch(name: str, *args: Any, **kwargs: Any) -> None:
+        try:
+            run_process(*args, **kwargs)
+        except KeyboardInterrupt:
+            print(f'[yellow]Task {name} was gracefully stopped[/yellow]')

amsdal_cli/commands/serve/utils.py

@@ -0,0 +1,16 @@
+import shutil
+from pathlib import Path
+
+
+def cleanup_app(output_path: Path) -> None:
+    """
+    Cleanup the generated models and files after stopping.
+    """
+
+    for path in (
+        (output_path / 'models'),
+        (output_path / 'schemas'),
+        (output_path / 'fixtures'),
+        (output_path / 'warehouse'),
+    ):
+        shutil.rmtree(str(path.resolve()))

amsdal_cli/commands/verify/command.py

@@ -0,0 +1,74 @@
+import tempfile
+import traceback
+from pathlib import Path
+
+import typer
+from amsdal_framework.configs.constants import CORE_SCHEMAS_PATH
+from amsdal_framework.configs.constants import TYPE_SCHEMAS_PATH
+from amsdal_models.classes.manager import ClassManager
+from amsdal_models.schemas.data_models.schemas_directory import SchemasDirectory
+from amsdal_utils.models.enums import SchemaTypes
+from rich import print
+
+from amsdal_cli.app import app
+from amsdal_cli.commands.generate.enums import MODEL_JSON_FILE
+from amsdal_cli.commands.generate.enums import SOURCES_DIR
+from amsdal_cli.commands.verify.utils.verify_json_model import verify_json_model
+from amsdal_cli.commands.verify.utils.verify_python_file import verify_python_file
+from amsdal_cli.utils.cli_config import CliConfig
+from amsdal_cli.utils.copier import walk
+
+
+@app.command(name='verify')
+def verify_command(
+    ctx: typer.Context,
+    *,
+    building: bool = typer.Option(False, help='Do verify model building?'),
+) -> None:
+    """
+    Verifies all application's files such as models, properties, transactions, etc.
+    """
+    cli_config: CliConfig = ctx.meta['config']
+    errors = []
+
+    print('[blue]Syntax checking...[/blue]', end=' ')
+
+    for file_item in walk(cli_config.app_directory / SOURCES_DIR):
+        if file_item.name == MODEL_JSON_FILE:
+            errors.extend(verify_json_model(file_item))
+        elif file_item.name.endswith('.py'):
+            errors.extend(verify_python_file(file_item))
+
+    if errors:
+        for error in errors:
+            print(f'[red]File: {error.file_path.resolve()}: {error.message}[/red]')
+            print(f'[red]{error.details}[/red]')
+
+        raise typer.Exit(1)
+
+    print('[green]OK![/green]')
+
+    if not building:
+        return
+
+    print('[blue]Build models checking...[/blue]', end=' ')
+    with tempfile.TemporaryDirectory() as _temp_dir:
+        output_path: Path = Path(_temp_dir)
+        class_manager = ClassManager()
+        class_manager.init_models_root(output_path / 'models')
+
+        try:
+            class_manager.generate_models(
+                [
+                    SchemasDirectory(path=TYPE_SCHEMAS_PATH, schema_type=SchemaTypes.TYPE),
+                    SchemasDirectory(path=CORE_SCHEMAS_PATH, schema_type=SchemaTypes.CORE),
+                    SchemasDirectory(
+                        path=cli_config.app_directory / SOURCES_DIR / 'models', schema_type=SchemaTypes.USER
+                    ),
+                ]
+            )
+        except Exception as ex:
+            print(f'[red]Failed: {ex} - {traceback.format_exc()}[/red]')
+            raise typer.Exit(1) from ex
+
+    print('[green]OK![/green]')

amsdal_cli/commands/verify/models.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class VerifyError(BaseModel):
+    file_path: Path
+    message: str
+    details: Any

amsdal_cli/commands/verify/utils/verify_json_model.py

@@ -0,0 +1,31 @@
+import json
+import traceback
+from json import JSONDecodeError
+from pathlib import Path
+
+from amsdal_cli.commands.verify.models import VerifyError
+
+
+def verify_json_model(model_file: Path) -> list[VerifyError]:
+    try:
+        with model_file.open('rt') as _file:
+            data = json.loads(_file.read())
+    except (JSONDecodeError, TypeError) as err:
+        return [
+            VerifyError(
+                file_path=model_file,
+                message='Cannot parse JSON file',
+                details=f'{err}: {traceback.format_exc()}',
+            ),
+        ]
+
+    if not isinstance(data, dict):
+        return [
+            VerifyError(
+                file_path=model_file,
+                message='Incorrect JSON format',
+                details=f'The JSON model should be defined as an object instead of {type(data)}',
+            ),
+        ]
+
+    return []

amsdal_cli/commands/verify/utils/verify_python_file.py

@@ -0,0 +1,21 @@
+import ast
+import traceback
+from pathlib import Path
+
+from amsdal_cli.commands.verify.models import VerifyError
+
+
+def verify_python_file(python_file: Path) -> list[VerifyError]:
+    try:
+        with python_file.open('rt') as _file:
+            ast.parse(_file.read())
+    except Exception as ex:
+        return [
+            VerifyError(
+                file_path=python_file,
+                message='Cannot parse PY file',
+                details=f'{ex}: {traceback.format_exc()}',
+            ),
+        ]
+
+    return []

amsdal_cli/config/main.py

@@ -0,0 +1,38 @@
+import importlib
+from types import ModuleType
+from typing import Any
+
+from pydantic import Field
+from pydantic import field_validator
+from pydantic_settings import BaseSettings
+from pydantic_settings import SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(case_sensitive=True)
+
+    COMMANDS: list[str] = Field(
+        default=[
+            'amsdal_cli.commands.new',
+            'amsdal_cli.commands.generate',
+            'amsdal_cli.commands.verify',
+            'amsdal_cli.commands.build',
+            'amsdal_cli.commands.serve',
+            # 'amsdal_cli.commands.migrate',
+            # 'amsdal_cli.commands.write_logs',
+        ]
+    )
+
+    @field_validator('COMMANDS')
+    @classmethod
+    def load_commands(cls, value: list[Any]) -> list[ModuleType]:
+        commands: list[ModuleType] = []
+
+        for module in value:
+            if isinstance(module, str):
+                commands.append(importlib.import_module(f'{module}.command'))
+
+        return commands
+
+
+settings = Settings()

amsdal_cli/main.py

@@ -0,0 +1,7 @@
+from amsdal_cli.app import app
+from amsdal_cli.config.main import settings
+
+__all__ = ['app']
+
+if __name__ == '__main__':
+    app(context_settings={'settings': settings})

amsdal_cli/utils/cli_config.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+
+from pydantic import BaseModel
+from pydantic import model_validator
+
+
+class CliConfig(BaseModel):
+    templates_path: Path
+    config_path: Path = Path('/dev/null')
+    http_port: int = 8080
+    check_model_exists: bool = True
+    json_indent: int = 4
+    app_directory: Path = Path('/dev/null')
+
+    @model_validator(mode='after')
+    def validate_config_path(self) -> 'CliConfig':
+        if self.app_directory == Path('/dev/null'):
+            return self
+
+        full_config_path: Path = self.app_directory / self.config_path
+        self.config_path = full_config_path
+
+        if not full_config_path.exists():
+            msg = f'The "{full_config_path}" does not exists. Check ".amdsal-cli -> config_path".'
+            raise ValueError(msg)
+
+        return self