skeleton-framework 0.1.0__py3-none-any.whl

skeleton/infrastructure/runners/src/parser.py

@@ -0,0 +1,84 @@
+from skeleton.infrastructure.runners.src.actions import ACTIONS
+
+# command line input may look like:
+# python run.py --start frontend gateway --watch --open
+# python run.py --start --watch --open
+
+# arguments are thus:
+# ["--start", "frontend", "gateway", "--watch", "--open"]
+
+def parse(argv: list[str]) -> dict:
+
+    action = "start" # default
+
+    targets: list[str] = [] # frontend, gateway, packages
+
+    options: dict[str, str | bool] = {
+        "mode": "dev",
+        "watch": False,
+        "open": False,
+    } # dev/prod
+    
+    if argv and argv[0] in ACTIONS:
+        action = ACTIONS[argv[0]]
+        i = 1
+    else:
+        i = 0
+
+    while i < len(argv):
+
+        arg = argv[i]
+
+        if arg.startswith("--"):
+            break
+
+        targets.append(arg)
+        i += 1
+
+    while i < len(argv):
+
+        arg = argv[i]
+
+        if arg == "--mode":
+    
+            if i + 1 >= len(argv):
+                raise ValueError("--mode requires a values to be specified")
+            
+            mode = argv[i + 1]
+
+            if mode not in ["dev", "prod"]:
+                raise ValueError(f"invalid mode: {mode}")
+            
+            options["mode"] = mode
+
+            i += 2
+            continue
+
+        if arg == "--root":
+    
+            if i + 1 >= len(argv):
+                raise ValueError("--root requires a values to be specified")
+            
+            root = argv[i + 1]
+            options["root"] = root
+
+            i += 2
+            continue
+
+        if arg == "--watch":
+            options["watch"] = True
+            i += 1
+            continue
+
+        if arg == "--open":
+            options["open"] = True
+            i += 1
+            continue
+
+        raise ValueError(f"Unknown option: {arg}")
+
+    return {
+        "action": action,
+        "targets": targets,
+        "options": options
+    }

skeleton/infrastructure/runners/src/process.py

@@ -0,0 +1,99 @@
+from subprocess import Popen
+
+from skeleton.infrastructure.runners.src.command import Command
+
+from skeleton.infrastructure.common.src.context import RuntimeContext
+
+from typing import Callable
+
+Hook = Callable[["ProcessManager"], None]
+
+class ProcessManager:
+
+    def __init__(self, context: RuntimeContext):
+
+        self.context = context
+
+        self.commands: list[Command] = []
+        self.processes: list[Popen] = []
+
+        self.before_start_hooks: list[Hook] = []
+        self.after_start_hooks: list[Hook] = []
+        self.on_shutdown_hooks: list[Hook] = []
+    
+    def register_hook(
+        self, hook: Hook,
+        phase: str = "before_start"
+    ):
+        if phase == "before_start":
+            self.before_start_hooks.append(hook)
+        elif phase == "after_start":
+            self.after_start_hooks.append(hook)
+        elif phase == "on_shutdown":
+            self.on_shutdown_hooks.append(hook)
+
+    def register(self, command: Command):
+        self.commands.append(command)
+    
+    def spawn(self, command: Command):
+        return Popen(
+            command.args,
+            cwd=command.cwd,
+            env=self.context.env,
+            shell=False,
+        )
+    
+    def start(self):
+
+        try:
+
+            # BEFORE START HOOKS
+            for hook in self.before_start_hooks:
+                hook(self)
+
+            # spawn processes
+            for command in self.commands:
+                self.processes.append(
+                    self.spawn(command)
+                )
+
+            # AFTER START HOOKS
+            for hook in self.after_start_hooks:
+                hook(self)
+
+            for p in self.processes:
+                p.wait()
+        
+        # fix this issues => twice:
+        # Terminate batch job (Y/N)?
+        # issue seems to be coming from npm, npx, etc.
+        except KeyboardInterrupt:
+
+            # When ctrl + C for shutdown:
+            
+            # Exception ignored on threading shutdown:
+            # Traceback (most recent call last):
+
+            # File "C:\Users\Lambda\AppData\Local\Programs\Python\Python313\Lib\threading.py", line 1540, in _shutdown
+            #     _thread_shutdown()
+
+            print("INFO: shutting down services ...")
+
+            # ON SHUTDOWN HOOKS!
+            for hook in self.on_shutdown_hooks:
+                hook(self)
+
+            for p in self.processes:
+                try:
+                    p.terminate()
+                except Exception:
+                    pass
+
+            for p in self.processes:
+                try:
+                    p.wait(timeout=3)
+                except Exception:
+                    try:
+                        p.kill()
+                    except Exception:
+                        pass

skeleton/infrastructure/runners/src/services.py

@@ -0,0 +1,16 @@
+from skeleton.infrastructure.runners.src import (
+    packages
+)
+from skeleton.infrastructure.runners.src import frontend, gateway
+
+# let tsc handle packages build-order
+SERVICES = {
+    "packages": packages,
+    "frontend": frontend,
+    "gateway": gateway,
+}
+
+DEFAULT_TARGETS = [
+    "frontend",
+    "gateway",
+]

skeleton/infrastructure/runners/src/utils.py

@@ -0,0 +1,6 @@
+import shutil
+
+def resolve_cmd(cmd):
+    # npm is npm.cmd on windows!
+    # use which to check if npm.cmd
+    return shutil.which(cmd) or cmd

skeleton/infrastructure/runners/src/validation.py

@@ -0,0 +1,28 @@
+from skeleton.infrastructure.runners.src.cmd import CMD
+from skeleton.infrastructure.runners.src.actions import ACTIONS
+from skeleton.infrastructure.runners.src.services import SERVICES
+
+class CMDValidationError(Exception):
+    pass
+
+def validate(cmd: CMD):
+
+    if cmd.action not in ACTIONS.values():
+        raise CMDValidationError(
+            f"Unknown action: {cmd.action}"
+        )
+
+    for target in cmd.targets:
+        
+        if target not in SERVICES:
+            raise CMDValidationError(
+                f"Unknown service: {target}"
+            )
+
+        service = SERVICES[target]
+
+        if not hasattr(service, cmd.action):
+            raise CMDValidationError(
+                f"Service {service}" f" "
+                f"does not have action {cmd.action}"
+            )

skeleton/root.py

@@ -0,0 +1,234 @@
+import shutil
+
+from pathlib import Path
+
+def _remove_path(
+    path: Path,
+) -> None:
+
+    if path.is_dir() and not path.is_symlink():
+
+        shutil.rmtree(path)
+
+        print(f"Removed directory: {path}")
+
+    elif path.is_file() or path.is_symlink():
+
+        path.unlink()
+
+        print(f"Removed file: {path}")
+
+def clean_framework(
+    framework_root: Path,
+) -> int:
+
+    framework_root = framework_root.resolve()
+
+    # Remove generated Python distribution artifacts and
+    # JavaScript/TypeScript package build outputs.
+    #
+    # Keep node_modules, lockfiles, the development virtual
+    # environment, and packaged framework tarballs intact.
+
+    targets = [
+        framework_root / "dist",
+        framework_root / "skeleton_framework.egg-info",
+        framework_root / ".mypy_cache",
+        framework_root / "skeleton" / "packages" / "cli" / "dist",
+        framework_root / "skeleton" / "packages" / "webpack" / "dist",
+    ]
+
+    for target in targets:
+
+        _remove_path(target)
+
+    # Remove TypeScript build information from the framework's
+    # own package sources without traversing node_modules.
+
+    package_directories = [
+        framework_root / "skeleton" / "packages" / "cli",
+        framework_root / "skeleton" / "packages" / "webpack",
+    ]
+
+    for directory in package_directories:
+
+        if not directory.is_dir():
+            continue
+
+        for target in directory.glob("*.tsbuildinfo"):
+
+            _remove_path(target)
+
+    print("Framework clean completed.")
+
+    return 0
+
+def purge_framework(
+    framework_root: Path,
+) -> int:
+
+    framework_root = framework_root.resolve()
+
+    # Purge includes clean, plus installed development
+    # dependencies, lockfiles, and packaged client tarballs.
+    #
+    # The framework's Python virtual environment is preserved.
+
+    clean_framework(framework_root)
+
+    targets = [
+        framework_root / "node_modules",
+        framework_root / "skeleton" / "packages" / "cli" / "node_modules",
+        framework_root / "skeleton" / "packages" / "webpack" / "node_modules",
+        framework_root / "package-lock.json",
+        framework_root / "skeleton" / "packages" / "cli" / "package-lock.json",
+        framework_root / "skeleton" / "packages" / "webpack" / "package-lock.json",
+        framework_root / "skeleton" / "packages" / ".skeleton",
+    ]
+
+    for target in targets:
+
+        _remove_path(target)
+
+    print("Framework purge completed.")
+
+    return 0
+
+def main(
+    argv: list[str] | None = None,
+    framework_root: Path | None = None,
+    project_root: Path | None = None,
+) -> int:
+
+    import sys
+
+    args = sys.argv[1:] if argv is None else argv
+
+    if framework_root is None:
+
+        framework_root = Path(__file__).resolve().parent.parent
+
+    framework_root = framework_root.resolve()
+
+    if project_root is None:
+
+        project_root = Path.cwd().resolve()
+
+    project_root = project_root.resolve()
+
+    from skeleton.cli import is_framework_repository
+
+    if not is_framework_repository(framework_root):
+
+        print(
+            "Error: Framework development commands require "
+            "the Skeleton framework source repository."
+        )
+
+        return 2
+
+    if not args:
+
+        print(
+            "Usage: python run.py "
+            "--bootstrap | --dist | --init | --install | "
+            "--pack | --build | --clean | --purge"
+        )
+
+        return 0
+
+    command = args[0]
+
+    if command == "--bootstrap":
+
+        from skeleton.infrastructure.bootstrap.src.commands.dev.init import (
+            dev_init,
+        )
+
+        from skeleton.infrastructure.bootstrap.src.commands.dev.install import (
+            dev_install,
+        )
+
+        print("\n[1/2] Initializing framework development...\n")
+
+        dev_init(framework_root)
+
+        print("\n[2/2] Installing framework development dependencies...\n")
+
+        dev_install(framework_root)
+
+        print("\nFramework bootstrap completed successfully.")
+
+        return 0
+
+    if command == "--dist":
+
+        from skeleton.infrastructure.bootstrap.src.commands.dev.pack import (
+            dev_pack,
+        )
+
+        from skeleton.infrastructure.bootstrap.src.commands.dev.build import (
+            dev_build,
+        )
+
+        print("\n[1/2] Packaging framework dependencies...\n")
+
+        dev_pack(framework_root)
+
+        print("\n[2/2] Building framework distribution...\n")
+
+        dev_build(framework_root)
+
+        print("\nFramework distribution completed successfully.")
+
+        return 0
+
+    if command == "--init":
+
+        from skeleton.infrastructure.bootstrap.src.commands.dev.init import (
+            dev_init,
+        )
+
+        dev_init(framework_root)
+
+        return 0
+
+    if command == "--install":
+
+        from skeleton.infrastructure.bootstrap.src.commands.dev.install import (
+            dev_install,
+        )
+
+        dev_install(framework_root)
+
+        return 0
+
+    if command == "--pack":
+
+        from skeleton.infrastructure.bootstrap.src.commands.dev.pack import (
+            dev_pack,
+        )
+
+        dev_pack(framework_root)
+
+        return 0
+
+    if command == "--build":
+
+        from skeleton.infrastructure.bootstrap.src.commands.dev.build import (
+            dev_build,
+        )
+
+        dev_build(framework_root)
+
+        return 0
+
+    if command == "--clean":
+
+        return clean_framework(framework_root)
+
+    if command == "--purge":
+
+        return purge_framework(framework_root)
+
+    raise ValueError(f"Unknown framework command: {command}")