amsdal_cli 0.9.5__tar.gz → 0.9.7__tar.gz

{amsdal_cli-0.9.5 → amsdal_cli-0.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amsdal_cli
-Version: 0.9.5
+Version: 0.9.7
 Summary: CLI for AMSDAL framework
 Project-URL: Documentation, https://pypi.org/project/amsdal_cli/#readme
 Project-URL: Issues, https://pypi.org/project/amsdal_cli/

{amsdal_cli-0.9.5 → amsdal_cli-0.9.7}/change-logs.md

@@ -1,3 +1,42 @@
+## [v0.9.7](https://pypi.org/project/amsdal_cli/0.9.7/) - 2026-06-23
+
+
+### Fixed
+
+- `cloud tunnel-db` now fails fast with a clear, actionable error when the local
+  port is already in use, instead of doing all the build/auth/remote work first
+  and then dying with a cryptic "might be in use" message from sshtunnel. The
+  preflight check runs before anything else and suggests picking another port
+  with `--local-port <PORT>`.
+
+## [v0.9.6](https://pypi.org/project/amsdal_cli/0.9.6/) - 2026-06-23
+
+
+### Changed
+
+- CLI start-up is significantly faster. Command modules are now imported lazily,
+  so running a single command no longer imports every command tree (and their
+  heavy dependencies such as pandas and the AMSDAL manager) on each invocation —
+  only the module for the invoked command is loaded.
+- The latest-version check against PyPI is now cached on disk for 20 minutes, so
+  most commands no longer make blocking network requests on start-up. The check
+  also applies a request timeout and no longer lets a network error (e.g. an
+  unreachable PyPI) crash the CLI.
+- GitPython is now imported only for projects that use git version control, and
+  the `cloud sync-db` database drivers are imported lazily, further reducing
+  start-up overhead.
+
+### Fixed
+
+- `cloud tunnel-db` now closes promptly instead of hanging until the database
+  client disconnects: the SSH transport is force-closed on stop so connection
+  handler threads exit immediately.
+- `cloud tunnel-db` now connects to the bastion on the correct SSH port and uses
+  a longer SSH handshake timeout with a keep-alive so idle tunnels are not
+  dropped. It runs a fast reachability pre-check that reports a clear, actionable
+  error instead of hanging for ~2 minutes when the bastion cannot be reached, and
+  verifies the tunnel is actually up before reporting success.
+
 ## [v0.9.5](https://pypi.org/project/amsdal_cli/0.9.5/) - 2026-06-17
 
 

amsdal_cli-0.9.7/latest-changelogs.md

@@ -0,0 +1,10 @@
+## [v0.9.7](https://pypi.org/project/amsdal_cli/0.9.7/) - 2026-06-23
+
+
+### Fixed
+
+- `cloud tunnel-db` now fails fast with a clear, actionable error when the local
+  port is already in use, instead of doing all the build/auth/remote work first
+  and then dying with a cryptic "might be in use" message from sshtunnel. The
+  preflight check runs before anything else and suggests picking another port
+  with `--local-port <PORT>`.

{amsdal_cli-0.9.5 → amsdal_cli-0.9.7}/src/amsdal_cli/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2023-present
 #
 # SPDX-License-Identifier: AMSDAL End User License Agreement
-__version__ = '0.9.5'
+__version__ = '0.9.7'

{amsdal_cli-0.9.5 → amsdal_cli-0.9.7}/src/amsdal_cli/app.py

@@ -2,7 +2,7 @@ import typer
 import typer.rich_utils
 
 from amsdal_cli.commands.callbacks import init_app_context
-from amsdal_cli.utils.alias_group import AliasGroup
+from amsdal_cli.utils.alias_group import LazyAliasGroup
 from amsdal_cli.utils.markdown_patch import get_custom_help_text
 
 # patch typer to use custom help text
@@ -13,5 +13,5 @@ app = typer.Typer(
     callback=init_app_context,
     invoke_without_command=True,
     rich_markup_mode='markdown',
-    cls=AliasGroup,
+    cls=LazyAliasGroup,
 )

{amsdal_cli-0.9.5 → amsdal_cli-0.9.7}/src/amsdal_cli/commands/callbacks.py

@@ -4,7 +4,6 @@ from json import JSONDecodeError
 from pathlib import Path
 
 import typer
-from amsdal_utils.config.manager import AmsdalConfigManager
 from rich import print as rprint
 from typer import Option
 
@@ -33,6 +32,8 @@ def init_app_context(
     Returns:
         None
     """
+    from amsdal_utils.config.manager import AmsdalConfigManager
+
     from amsdal_cli.commands.cloud.environments.utils import get_current_env
     from amsdal_cli.config.main import settings
     from amsdal_cli.utils.check_versions import check_latest_amsdal_version

{amsdal_cli-0.9.5 → amsdal_cli-0.9.7}/src/amsdal_cli/commands/cloud/sub_commands/sync_db.py

@@ -4,10 +4,8 @@ import typing
 from pathlib import Path
 from typing import Union
 
-import amsdal_glue as glue
 import typer
 import yaml
-from amsdal_data.connections.db_alias_map import CONNECTION_BACKEND_ALIASES
 from rich import print as rprint
 from typer import Option
 
@@ -213,6 +211,8 @@ def _build_config(secrets: dict[str, str], db_type: DBType) -> Path:
 
 
 def _copy_data(config: 'AmsdalConfig', connection_names: list[tuple[str, str]]) -> None:
+    import amsdal_glue as glue
+    from amsdal_data.connections.db_alias_map import CONNECTION_BACKEND_ALIASES
     from amsdal_utils.utils.classes import import_class
 
     for from_name, to_name in connection_names:

{amsdal_cli-0.9.5 → amsdal_cli-0.9.7}/src/amsdal_cli/commands/cloud/sub_commands/tunnel_db.py

@@ -1,4 +1,5 @@
 import os
+import socket
 import tempfile
 import typing
 from pathlib import Path
@@ -10,6 +11,19 @@ from typer import Option
 from amsdal_cli.commands.cloud.app import cloud_sub_app
 from amsdal_cli.utils.auth import ensure_authenticated
 
+# The cloud bastion exposes SSH on this port (not the default 22).
+BASTION_SSH_PORT = 5444
+
+
+def _is_local_port_available(port: int) -> bool:
+    """Return True if the tunnel can bind 127.0.0.1:<port>, False if it is taken."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        try:
+            sock.bind(('127.0.0.1', port))
+        except OSError:
+            return False
+    return True
+
 
 def _generate_temp_ssh_key() -> tuple[bytes, bytes]:
     """Generate an ephemeral RSA key pair in OpenSSH format."""
@@ -72,6 +86,18 @@ def tunnel_db_command(
     if cli_config.verbose:
         rprint(rich_info(f'Opening database tunnel for environment: {rich_highlight(env_name)}'))
 
+    # Preflight: bail before any build/auth/remote work if the local port is taken,
+    # otherwise sshtunnel fails later with a cryptic "might be in use" message.
+    if not _is_local_port_available(local_port):
+        rprint(
+            rich_error(
+                f'Local port {rich_highlight(str(local_port))} is already in use. '
+                f'Close whatever is using it, or pick another port with '
+                f'{rich_highlight("--local-port <PORT>")}.'
+            )
+        )
+        return
+
     with tempfile.TemporaryDirectory() as _temp_dir:
         output_path: Path = Path(_temp_dir)
 
@@ -106,16 +132,44 @@ def tunnel_db_command(
 
     tunnel: SSHTunnelForwarder | None = None
 
+    # sshtunnel's module-default SSH_TIMEOUT is 0.1s, far too short to complete
+    # an SSH handshake to a remote bastion, so start() can fail to connect.
+    import sshtunnel
+
+    sshtunnel.SSH_TIMEOUT = 10.0
+
+    # Preflight: paramiko opens the bastion socket with no connect timeout, so an
+    # unreachable bastion port hangs for the full OS TCP timeout (~2 min). Fail
+    # fast with a clear, actionable message instead.
+    try:
+        with socket.create_connection((details['bastion_host'], BASTION_SSH_PORT), timeout=10):
+            pass
+    except OSError as e:
+        rprint(
+            rich_error(
+                f'Cannot reach bastion {details["bastion_host"]}:{BASTION_SSH_PORT} ({e}). '
+                f'Check that your IP is allowed on the bastion security group and that '
+                f'outbound port {BASTION_SSH_PORT} is not blocked by your network/VPN.'
+            )
+        )
+        os.unlink(key_path)
+        return
+
     try:
         tunnel = SSHTunnelForwarder(
-            (details['bastion_host'], 22),
+            (details['bastion_host'], BASTION_SSH_PORT),
             ssh_username=details['ssh_user'],
             ssh_pkey=key_path,
             remote_bind_address=(details['rds_host'], int(details['rds_port'] or db_port)),
             local_bind_address=('127.0.0.1', local_port),
+            set_keepalive=30.0,
         )
         tunnel.start()
 
+        if not tunnel.is_active or not all(tunnel.tunnel_is_up.values()):
+            rprint(rich_error('Failed to establish the database tunnel.'))
+            return
+
         rprint(
             rich_success(
                 f'Tunnel open. Connect your SQL client to {rich_highlight(f"127.0.0.1:{local_port}")}',
@@ -128,6 +182,9 @@ def tunnel_db_command(
         rprint(rich_error(f'Failed to open tunnel: {e}'))
     finally:
         if tunnel is not None:
-            tunnel.stop()
+            # force=True closes the SSH transport first so active connection
+            # handler threads exit immediately; without it stop() blocks
+            # joining those threads until the SQL client disconnects.
+            tunnel.stop(force=True)
         os.unlink(key_path)
         rprint(rich_info('Tunnel closed.'))

{amsdal_cli-0.9.5 → amsdal_cli-0.9.7}/src/amsdal_cli/config/main.py

@@ -1,14 +1,38 @@
-import importlib
-from types import ModuleType
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import TypeAlias
 
 from pydantic import Field
-from pydantic import field_validator
 from pydantic_settings import BaseSettings
 from pydantic_settings import SettingsConfigDict
 
+# Maps each top-level command name (including its comma-separated aliases, exactly
+# as registered via ``@app.command`` / ``app.add_typer``) to the module whose
+# ``.command`` submodule registers it on the root Typer ``app``.
+#
+# This is the single source of truth for lazy command loading: the root group
+# (``LazyAliasGroup``) imports a module only when its command is actually invoked,
+# instead of importing all 16 command trees on every CLI start. See
+# ``amsdal_cli/utils/alias_group.py``.
+COMMAND_REGISTRY: dict[str, str] = {
+    'api-check': 'amsdal_cli.commands.api_check',
+    'new, n': 'amsdal_cli.commands.new',
+    'plugin': 'amsdal_cli.commands.plugin',
+    'generate, gen, g': 'amsdal_cli.commands.generate',
+    'verify, vrf, v': 'amsdal_cli.commands.verify',
+    'build, bld, b': 'amsdal_cli.commands.build',
+    'clean, cln': 'amsdal_cli.commands.clean',
+    'serve, srv, s': 'amsdal_cli.commands.serve',
+    'restore, rst': 'amsdal_cli.commands.restore',
+    'cloud, cld': 'amsdal_cli.commands.cloud',
+    'migrations, migs, mgs': 'amsdal_cli.commands.migrations',
+    'ci-cd': 'amsdal_cli.commands.ci_cd',
+    'tests, test': 'amsdal_cli.commands.tests',
+    'worker, w': 'amsdal_cli.commands.worker',
+    'register-connection, reg-conn': 'amsdal_cli.commands.register_connection',
+    'gen-token, gen_token, gt': 'amsdal_cli.commands.gen_token',
+}
+
 
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(
@@ -18,43 +42,16 @@ class Settings(BaseSettings):
         extra='ignore',
     )
 
-    COMMANDS: list[str | ModuleType] = Field(
-        default=[
-            'amsdal_cli.commands.api_check',
-            'amsdal_cli.commands.new',
-            'amsdal_cli.commands.plugin',
-            'amsdal_cli.commands.generate',
-            'amsdal_cli.commands.verify',
-            'amsdal_cli.commands.build',
-            'amsdal_cli.commands.clean',
-            'amsdal_cli.commands.serve',
-            'amsdal_cli.commands.restore',
-            'amsdal_cli.commands.cloud',
-            'amsdal_cli.commands.migrations',
-            'amsdal_cli.commands.ci_cd',
-            'amsdal_cli.commands.tests',
-            'amsdal_cli.commands.worker',
-            'amsdal_cli.commands.register_connection',
-            'amsdal_cli.commands.gen_token',
-        ]
-    )
+    # Module paths of the registered commands. Kept for backwards compatibility;
+    # commands are now loaded lazily through COMMAND_REGISTRY, so importing this
+    # settings object no longer imports any command module.
+    COMMANDS: list[str] = Field(default=list(COMMAND_REGISTRY.values()))
 
     CHECK_AMSDAL_VERSIONS: bool = True
     """If True, the latest version of the amsdal modules will be checked and displayed."""
     AMSDAL_APPLICATION_UUID: str | None = None
     """The UUID of the application."""
 
-    @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
-
 
 if TYPE_CHECKING:
     base: TypeAlias = Settings

amsdal_cli-0.9.7/src/amsdal_cli/utils/alias_group.py

@@ -0,0 +1,111 @@
+import importlib
+import re
+from typing import Any
+
+from click import Command
+from typer import Context
+from typer.core import TyperGroup
+
+
+class AliasGroup(TyperGroup):
+    """
+    A custom TyperGroup that supports aliasing commands.
+    """
+
+    _CMD_SPLIT_P = r'[,| ?\/]'
+
+    def get_command(self, ctx: Context, cmd_name: str) -> Command | None:  # type: ignore[override]
+        """
+        Get the command associated with the given command name.
+
+        Args:
+            ctx (Context): The Typer context object.
+            cmd_name (str): The name of the command to retrieve.
+
+        Returns:
+            Command | None: The command object if found, otherwise None.
+        """
+        cmd_name = self._group_cmd_name(cmd_name)
+        return super().get_command(ctx, cmd_name)
+
+    def _group_cmd_name(self, default_name: str) -> str:
+        for cmd in self.commands.values():
+            if cmd.name and default_name in re.split(self._CMD_SPLIT_P, cmd.name):
+                return cmd.name
+        return default_name
+
+
+class LazyAliasGroup(AliasGroup):
+    """
+    Root command group that imports a command's module only when it is invoked.
+
+    The default flow imported all 16 command trees on every CLI start (dragging in
+    pandas, the AMSDAL manager, etc.) just to register them. Instead, this group
+    starts empty and, on demand, imports the single module that registers the
+    requested command onto the root Typer ``app``, then materialises it.
+
+    ``--help`` and shell completion still need the full list, so ``list_commands``
+    loads everything; a specific command invocation only pays for its own module.
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+        from amsdal_cli.config.main import COMMAND_REGISTRY
+
+        # token (canonical name or alias) -> module that registers it
+        self._token_to_module: dict[str, str] = {}
+        for full_name, module in COMMAND_REGISTRY.items():
+            for token in re.split(self._CMD_SPLIT_P, full_name):
+                if token:
+                    self._token_to_module[token] = module
+
+        # ordered, de-duplicated module list for whole-registry loads
+        self._all_modules: list[str] = list(dict.fromkeys(COMMAND_REGISTRY.values()))
+        self._loaded_modules: set[str] = set()
+
+    def _sync_from_app(self) -> None:
+        """Materialise any newly registered Typer commands/groups into this group."""
+        from typer.main import get_command_from_info
+        from typer.main import get_group_from_info
+
+        from amsdal_cli.app import app
+
+        markup = self.rich_markup_mode
+        short = app.pretty_exceptions_short
+
+        for command_info in app.registered_commands:
+            command = get_command_from_info(command_info, pretty_exceptions_short=short, rich_markup_mode=markup)
+            if command.name and command.name not in self.commands:
+                self.commands[command.name] = command
+
+        for group_info in app.registered_groups:
+            group = get_group_from_info(group_info, pretty_exceptions_short=short, rich_markup_mode=markup)
+            if group.name and group.name not in self.commands:
+                self.commands[group.name] = group
+
+    def _load_module(self, module: str) -> None:
+        if module in self._loaded_modules:
+            return
+        importlib.import_module(f'{module}.command')
+        self._loaded_modules.add(module)
+        self._sync_from_app()
+
+    def _load_all(self) -> None:
+        for module in self._all_modules:
+            self._load_module(module)
+
+    def get_command(self, ctx: Context, cmd_name: str) -> Command | None:  # type: ignore[override]
+        if self._group_cmd_name(cmd_name) not in self.commands:
+            module = self._token_to_module.get(cmd_name)
+            if module is not None:
+                self._load_module(module)
+            else:
+                # Unknown token (e.g. a typo): load everything so resolution and
+                # the "no such command" suggestions behave exactly as before.
+                self._load_all()
+        return super().get_command(ctx, cmd_name)
+
+    def list_commands(self, ctx: Context) -> list[str]:  # type: ignore[override]
+        self._load_all()
+        return super().list_commands(ctx)

amsdal_cli-0.9.7/src/amsdal_cli/utils/check_versions.py

@@ -0,0 +1,109 @@
+import importlib
+import json
+import tempfile
+import time
+from pathlib import Path
+
+import httpx
+from rich import print as rprint
+
+from amsdal_cli.utils.text import rich_command
+from amsdal_cli.utils.text import rich_highlight_version
+
+AMSDAL_MODULES = [
+    'amsdal_utils',
+    'amsdal_data',
+    'amsdal_models',
+    'amsdal',
+    'amsdal_server',
+    'amsdal_cli',
+]
+
+# Latest versions on PyPI change rarely, but this check runs on every project
+# command and makes one blocking request per module. Cache the fetched versions
+# on disk for 20 minutes so most invocations skip the network entirely.
+_CACHE_TTL_SECONDS = 20 * 60
+_CACHE_PATH = Path(tempfile.gettempdir()) / 'amsdal_cli_latest_versions.json'
+
+
+def _read_cached_versions() -> dict[str, str] | None:
+    """Return cached ``{module: latest_version}`` if the cache is fresh, else None."""
+    try:
+        payload = json.loads(_CACHE_PATH.read_text())
+        fetched_at = float(payload['fetched_at'])
+        versions = payload['versions']
+    except (OSError, ValueError, KeyError, TypeError):
+        return None
+
+    if not isinstance(versions, dict) or time.time() - fetched_at > _CACHE_TTL_SECONDS:
+        return None
+
+    return versions
+
+
+def _write_cached_versions(versions: dict[str, str]) -> None:
+    try:
+        _CACHE_PATH.write_text(json.dumps({'fetched_at': time.time(), 'versions': versions}))
+    except OSError:
+        # Caching is best-effort; a failure here must never break the command.
+        pass
+
+
+def _fetch_latest_versions() -> dict[str, str]:
+    """Fetch the latest version of each AMSDAL module from PyPI.
+
+    Modules that cannot be reached (network/HTTP/parse errors) are skipped rather
+    than raising, so an offline machine or a PyPI hiccup never breaks the CLI.
+    """
+    versions: dict[str, str] = {}
+
+    with httpx.Client(timeout=5.0) as session:
+        for amsdal_module in AMSDAL_MODULES:
+            try:
+                response = session.get(f'https://pypi.org/pypi/{amsdal_module}/json')
+                versions[amsdal_module] = response.json()['info']['version']
+            except (httpx.HTTPError, KeyError, ValueError):
+                continue
+
+    return versions
+
+
+def check_latest_amsdal_version() -> None:
+    """
+    Check the latest version of AMSDAL modules and suggest upgrades if necessary.
+
+    Returns:
+        None
+    """
+    latest_versions = _read_cached_versions()
+    if latest_versions is None:
+        latest_versions = _fetch_latest_versions()
+        _write_cached_versions(latest_versions)
+
+    modules_to_update: list[str] = []
+
+    for amsdal_module in AMSDAL_MODULES:
+        latest_version = latest_versions.get(amsdal_module)
+        if not latest_version:
+            continue
+
+        try:
+            module = importlib.import_module(f'{amsdal_module}.__about__')
+        except ImportError:
+            continue
+
+        current_version = module.__version__
+
+        if current_version == latest_version:
+            continue
+
+        rprint(
+            f'You are using {amsdal_module} version {rich_highlight_version(current_version)}, '
+            f'however version {rich_highlight_version(latest_version)} is available.'
+        )
+
+        modules_to_update.append(amsdal_module)
+
+    if modules_to_update:
+        upgrade_command = 'pip install --upgrade ' + ' '.join(modules_to_update)
+        rprint(f"You should consider upgrading via the '{rich_command(upgrade_command)}' command.")

{amsdal_cli-0.9.5 → amsdal_cli-0.9.7}/src/amsdal_cli/utils/vcs/__init__.py

@@ -3,7 +3,6 @@ from typing import TYPE_CHECKING
 from amsdal_cli.utils.vcs.base import VCSBaseService
 from amsdal_cli.utils.vcs.dummy import DummyVSCService
 from amsdal_cli.utils.vcs.enums import VCSOptions
-from amsdal_cli.utils.vcs.git import GitService
 
 if TYPE_CHECKING:
     from amsdal_cli.utils.cli_config import CliConfig
@@ -11,6 +10,10 @@ if TYPE_CHECKING:
 
 def get_vcs_service(config: 'CliConfig') -> VCSBaseService:
     if config.vcs == VCSOptions.git:
+        # Imported lazily so projects that don't use git (the default) never pay
+        # the cost of loading GitPython, which runs on every project command.
+        from amsdal_cli.utils.vcs.git import GitService
+
         return GitService(config)
     return DummyVSCService(config)