amsdal_cli 0.5.2__tar.gz → 0.5.3__tar.gz

{amsdal_cli-0.5.2 → amsdal_cli-0.5.3}/.gitignore

@@ -2,6 +2,7 @@
 /.vscode
 /.env*
 venv
+.venv
 coverage.*
 .coverage*
 .mypy_cache

amsdal_cli-0.5.3/.junie/guidelines.md

@@ -0,0 +1,102 @@
+# Project Guidelines
+
+## Project Overview
+
+AMSDAL CLI is a command-line interface for the AMSDAL (A. Michael Salem Data Access Layer) framework. It provides tools for managing AMSDAL applications, including:
+
+- Generating code from models
+- Running a development server
+- Managing migrations
+- Testing and verification
+- Cloud integration
+
+The project is structured as follows:
+
+- `src/amsdal_cli/` - Main source code
+  - `commands/` - CLI commands implementation
+  - `config/` - Configuration management
+  - `utils/` - Utility functions and helpers
+- `tests/` - Test suite
+  - `async/` - Asynchronous tests
+  - `e2e/` - End-to-end tests
+  - `fixtures/` - Test fixtures
+  - `sync/` - Synchronous tests
+
+The CLI is built using Typer and follows a command-based structure with subcommands organized in modules.
+
+## Code Style Guide
+
+### Python Version
+- Target Python version: 3.11+
+- Code should be compatible with Python 3.10+ for development
+
+### Formatting
+- Line length: 120 characters
+- Use Black for code formatting
+- Use single quotes for strings, except for docstrings which use double quotes
+- Imports should be on separate lines (no multi-imports)
+- Imports should be ordered by type (standard library, third-party, first-party)
+
+### Type Annotations
+- All code must use type annotations
+- Use `typing.TYPE_CHECKING` for import-only type dependencies
+- Follow strict mypy rules:
+  - No implicit reexports
+  - Disallow untyped definitions
+  - Disallow any generics
+  - Check untyped definitions
+
+### Linting
+- Use Ruff for linting with the following rule sets enabled:
+  - A: flake8-builtins
+  - ARG: flake8-unused-arguments
+  - B: flake8-bugbear
+  - C: flake8-comprehensions
+  - DTZ: flake8-datetimez
+  - E: pycodestyle errors
+  - EM: flake8-errmsg
+  - F: pyflakes
+  - FBT: flake8-boolean-trap
+  - I: isort
+  - ICN: flake8-import-conventions
+  - ISC: flake8-implicit-str-concat
+  - N: pep8-naming
+  - PLC, PLE, PLR, PLW: pylint
+  - Q: flake8-quotes
+  - RUF: Ruff-specific rules
+  - S: flake8-bandit
+  - T: flake8-debugger
+  - TID: flake8-tidy-imports
+  - UP: pyupgrade
+  - W: pycodestyle warnings
+  - YTT: flake8-2020
+
+### Imports
+- No relative imports
+- Group imports by source (standard library, third-party, first-party)
+- Known first-party modules: amsdal_cli
+
+### Documentation
+- Use docstrings for functions, classes, and modules
+- Use markdown formatting in docstrings
+- Include help text for CLI commands and options
+
+### Testing
+- Write tests for all functionality
+- Use pytest for testing
+- Include both synchronous and asynchronous tests where appropriate
+- Use fixtures for test data
+- Aim for high test coverage
+
+### Error Handling
+- Use appropriate exception handling with try/except/finally blocks
+- Properly clean up resources in finally blocks
+
+### Asynchronous Code
+- Support both synchronous and asynchronous execution paths where needed
+- Use asyncio for asynchronous code
+- Follow asyncio best practices
+
+### Version Control
+- Use towncrier for managing release notes
+- Organize changes by type (security, removed, deprecated, added, changed, fixed, performance)

{amsdal_cli-0.5.2 → amsdal_cli-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amsdal_cli
-Version: 0.5.2
+Version: 0.5.3
 Summary: CLI for AMSDAL framework
 Project-URL: Documentation, https://pypi.org/project/amsdal_cli/#readme
 Project-URL: Issues, https://pypi.org/project/amsdal_cli/
@@ -125,6 +125,7 @@ Requires-Dist: amsdal-server==0.5.*
 Requires-Dist: click<8.2.0
 Requires-Dist: faker==27.*
 Requires-Dist: gitpython~=3.1
+Requires-Dist: httpx==0.28.*
 Requires-Dist: jinja2~=3.1
 Requires-Dist: pydantic-settings~=2.2
 Requires-Dist: pydantic~=2.3

{amsdal_cli-0.5.2 → amsdal_cli-0.5.3}/change-logs.md

@@ -1,3 +1,9 @@
+## [v0.5.3](https://pypi.org/project/amsdal_cli/0.5.3/) - 2025-08-01
+
+### Changed
+
+- Switched to use `uv` package manager
+
 ## [v0.5.2](https://pypi.org/project/amsdal_cli/0.5.2/) - 2025-07-11
 
 ### Added

amsdal_cli-0.5.3/latest-changelogs.md

@@ -0,0 +1,5 @@
+## [v0.5.3](https://pypi.org/project/amsdal_cli/0.5.3/) - 2025-08-01
+
+### Changed
+
+- Switched to use `uv` package manager

{amsdal_cli-0.5.2 → amsdal_cli-0.5.3}/pyproject.toml

@@ -41,6 +41,32 @@ dependencies = [
     "GitPython~=3.1",
     "amsdal-server==0.5.*",
     "faker==27.*",
+    "httpx==0.28.*",
+]
+
+[dependency-groups]
+dev = [
+    "amsdal[async-sqlite]",
+    "amsdal[postgres-binary]",
+    "coverage[toml]>=7.4",
+    "pytest-cov>=6.0.0",
+    "pytest==8.4.1",
+    "pytest-mock==3.14.1",
+    "pytest-asyncio>=1.1.0",
+    "pytest-xdist[psutil]>=3.8.0",
+    "black>=24.3.0",
+    "mypy>=1.17.0",
+    "ruff>=0.12.4",
+    "towncrier==23.11.0",
+    "types-ujson",
+    "types-PyYAML",
+    "types-pytz",
+    "types-pexpect",
+    "types-docutils",
+    "types-defusedxml",
+    "types-colorama",
+    "types-Pygments",
+    "pandas-stubs",
 ]
 
 [tool.hatch.envs.default.env-vars]
@@ -61,25 +87,16 @@ allow-direct-references = true
 path = "src/amsdal_cli/__about__.py"
 
 [[tool.hatch.envs.all.matrix]]
-python = ["3.10", "3.11", "3.12"]
+python = ["3.11", "3.12"]
 
 [tool.hatch.envs.default]
-path = "../.venv/amsdal_cli"
-dependencies = [
-    "coverage[toml]>=7.4",
-    "pytest-cov>=6.0.0",
-    "pytest==8.3.4",
-    "pytest-mock==3.14.0",
-    "pytest-asyncio>=0.25.3",
-    "pytest-xdist[psutil]>=3.6.1",
-    "black>=24.3.0",
-    "mypy>=1.15.0",
-    "ruff>=0.11.0",
-    "towncrier==23.11.0",
-    "aiosqlite",
-]
+installer = "uv"
+path = ".venv"
 
 [tool.hatch.envs.default.scripts]
+sync = "uv sync --group dev"
+lock = "uv lock"
+lock-upgrade = "uv lock --upgrade"
 test = "pytest -n auto {args:tests}"
 test-single = "pytest -vvv {args:tests}"
 test-cov = "pytest -n auto --cov=src {args:tests}"
@@ -107,31 +124,23 @@ release = "rm latest-changelogs.md && towncrier build --yes --version {args:vers
 COLUMNS = "200"
 
 [tool.hatch.envs.local]
-template = "local"
-path = "../.venv/amsdal_cli_local"
-dependencies = [
-    "pytest-cov>=6.0.0",
-    "pytest==8.3.4",
-    "pytest-mock==3.14.0",
-    "pytest-asyncio>=0.25.3",
-    "pytest-xdist[psutil]>=3.6.1",
-    "black>=24.3.0",
-    "mypy>=1.15.0",
-    "ruff>=0.11.0",
-    "aiosqlite",
-]
+installer = "uv"
+path = ".venv"
 pre-install-commands = [
-    "pip install -e ../amsdal-glue/libs/core/",
-    "pip install -e ../amsdal-glue/libs/connections/[postgres-binary]",
-    "pip install -e ../amsdal-glue/libs/amsdal-glue/",
-    "pip install -e ../amsdal_utils/",
-    "pip install -e ../amsdal_data/",
-    "pip install -e ../amsdal_models/",
-    "pip install -e ../amsdal_framework/",
-    "pip install -e ../amsdal_server/",
+    "uv pip install -e ../amsdal-glue/libs/core/",
+    "uv pip install -e ../amsdal-glue/libs/connections/",
+    "uv pip install -e ../amsdal-glue/libs/amsdal-glue/",
+    "uv pip install -e ../amsdal_utils/",
+    "uv pip install -e ../amsdal_data/",
+    "uv pip install -e ../amsdal_models/",
+    "uv pip install -e ../amsdal_framework/",
+    "uv pip install -e ../amsdal_server/",
 ]
 
 [tool.hatch.envs.local.scripts]
+sync = "uv sync --group dev"
+lock = "uv lock"
+lock-upgrade = "uv lock --upgrade"
 test = "pytest -n auto {args:tests}"
 test-single = "pytest -vvv {args:tests}"
 test-cov = "pytest -n auto --cov=src {args:tests}"
@@ -155,10 +164,10 @@ all = [
 
 
 [tool.black]
-target-version = ["py310"]
+target-version = ["py311"]
 line-length = 120
 skip-string-normalization = true
-exclude = "tests/fixtures/*"
+exclude = "tests/fixtures/*|.venv"
 
 [tool.mypy]
 plugins = ["pydantic.mypy"]

{amsdal_cli-0.5.2 → amsdal_cli-0.5.3}/src/amsdal_cli/__about__.py

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

amsdal_cli-0.5.3/src/amsdal_cli/commands/api_check/command.py

@@ -0,0 +1,118 @@
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from amsdal_cli.app import app
+from amsdal_cli.commands.api_check.config import ApiCheckConfig
+from amsdal_cli.commands.api_check.services.comparison import check
+from amsdal_cli.commands.api_check.services.loader import load_operation_logs
+from amsdal_cli.commands.api_check.services.runner import ApiRunner
+from amsdal_cli.commands.api_check.services.storage import save
+
+
+@app.command(name='api-check')
+def api_check(
+    target_url: str = typer.Argument(  # noqa: B008
+        ...,
+        help='Target API base URL to test',
+    ),
+    config_file: Path = typer.Option(  # noqa: B008
+        Path('api-check-config.json'),
+        '--config',
+        '-c',
+        help='Path to configuration file (YAML or JSON) with test cases and auth settings',
+        exists=True,
+    ),
+    compare_url: Optional[str] = typer.Option(  # noqa: B008
+        None,
+        '--compare-url',
+        help='Second API base URL to compare against',
+    ),
+    compare_logs: Optional[Path] = typer.Option(  # noqa: B008
+        None,
+        '--compare-logs',
+        help='Path to existing logs file to compare against',
+        exists=True,
+    ),
+    output_logs: Optional[Path] = typer.Option(  # noqa: B008
+        None,
+        '--output',
+        '-o',
+        help='Path to save output logs',
+    ),
+) -> None:
+    """
+    Run API tests against target URL and compare results with another endpoint or saved logs.
+
+    The command requires a configuration file (in YAML or JSON format) that defines:
+    - Test cases with inputs and expected outputs
+    - Authentication settings
+    - Endpoints to test
+
+    Authentication can be configured using environment variables:
+    - AMSDAL_API_CHECK_AUTHORIZATION: Authorization token
+    - AMSDAL_API_CHECK_EMAIL: Email for authentication
+    - AMSDAL_API_CHECK_PASSWORD: Password for authentication
+
+    If the token is invalid and no credentials are provided, the command will exit with an error.
+
+    Examples:
+
+    1. Save logs to a file without comparison:
+       ```
+       amsdal api-check https://api.example.com --compare-url https://api.example.com --output logs.json
+       ```
+       This uses the same URL for both target and comparison, which skips the comparison
+       but still runs the API checks and saves the logs.
+
+    2. Compare a URL with previously saved logs:
+       ```
+       amsdal api-check https://api.example.com --compare-logs previous-logs.json
+       ```
+       This runs API checks against the target URL and compares the results with
+       the logs stored in previous-logs.json.
+
+    3. Compare two different URLs:
+       ```
+       amsdal api-check https://api-prod.example.com --compare-url https://api-staging.example.com
+       ```
+       This runs API checks against both URLs and compares the results.
+
+    You can combine these options as needed:
+       ```
+       amsdal api-check https://api-prod.example.com --compare-url https://api-staging.example.com \
+           --output comparison.json
+       ```
+       This compares the two URLs and also saves the logs from the target URL.
+    """
+    if not compare_url and not compare_logs:
+        msg = 'Either --compare-url or --compare-logs must be provided'
+        raise typer.BadParameter(msg)
+
+    if compare_url and compare_logs:
+        msg = 'Cannot use both --compare-url and --compare-logs simultaneously'
+        raise typer.BadParameter(msg)
+
+    # Load configuration using the class method
+    config = ApiCheckConfig.load_from_file(config_file)
+
+    # Create runner with the loaded config
+    target_runner = ApiRunner(target_url, config)
+    target_logs_data = target_runner.run()
+    has_errors = False
+
+    if compare_url != target_url:
+        if compare_url:
+            compare_runner = ApiRunner(compare_url, config)
+            compare_logs_data = compare_runner.run()
+        else:
+            compare_logs_data = load_operation_logs(compare_logs)  # type: ignore[arg-type]
+
+        has_errors = check(target_logs_data, compare_logs_data)
+
+    if output_logs:
+        save(target_logs_data, destination=output_logs)
+
+    if has_errors:
+        raise typer.Exit(code=1)

amsdal_cli-0.5.3/src/amsdal_cli/commands/api_check/config.py

@@ -0,0 +1,192 @@
+import json
+import logging
+import os
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+from typing import ClassVar
+from typing import Literal
+from typing import Optional
+
+import yaml
+from pydantic import BaseModel
+from pydantic import Field
+
+logger = logging.getLogger(__name__)
+
+
+class TransactionData(BaseModel):
+    transaction_name: str
+    input_params: dict[str, Any] = Field(default_factory=dict)
+    expected_response: Any = None
+
+
+class ApiCheckConfig(BaseModel):
+    # Class variable to store the config file path
+    _config_file: ClassVar[Optional[Path]] = None
+
+    items_per_list: tuple[int, int, int] = (5, 5, 5)
+    headers: dict[str, str] = Field(default_factory=dict)
+    auth_headers: dict[str, str] = Field(default_factory=dict)
+    request_timeout: int = 600
+    extend_output: bool = True
+
+    # Authentication
+    email: Optional[str] = None
+    password: Optional[str] = None
+
+    @property
+    def token(self) -> Optional[str]:
+        """
+        Get the token from auth_headers.
+
+        Returns:
+            Optional[str]: The token or None if not set
+        """
+        if not self.auth_headers or 'Authorization' not in self.auth_headers:
+            return None
+
+        return self.auth_headers['Authorization']
+
+    @token.setter
+    def token(self, value: Optional[str]) -> None:
+        """
+        Set the token in auth_headers.
+
+        Args:
+            value: The token value
+        """
+        if value is None:
+            if 'Authorization' in self.auth_headers:
+                del self.auth_headers['Authorization']
+        else:
+            self.auth_headers['Authorization'] = value
+
+    @property
+    def token_expiry(self) -> Optional[int]:
+        """
+        Get the token expiry from the token.
+
+        Returns:
+            Optional[int]: The token expiry timestamp, or None if not available
+        """
+        if not self.token:
+            return None
+
+        try:
+            import jwt
+
+            decoded = jwt.decode(self.token, options={'verify_signature': False})
+            return decoded.get('exp')
+        except Exception as e:
+            logger.warning(f'Failed to decode token: {e}')
+            return None
+
+    @property
+    def env_authorization(self) -> Optional[str]:
+        """Get authorization token from environment variable."""
+        return os.environ.get('AMSDAL_API_CHECK_AUTHORIZATION')
+
+    @property
+    def env_email(self) -> Optional[str]:
+        """Get email from environment variable."""
+        return os.environ.get('AMSDAL_API_CHECK_EMAIL')
+
+    @property
+    def env_password(self) -> Optional[str]:
+        """Get password from environment variable."""
+        return os.environ.get('AMSDAL_API_CHECK_PASSWORD')
+
+    @classmethod
+    def load_from_file(cls, config_file: str | Path) -> 'ApiCheckConfig':
+        """
+        Load configuration from a file.
+
+        Args:
+            config_file: Path to the configuration file (YAML or JSON)
+
+        Returns:
+            ApiCheckConfig: The loaded configuration
+        """
+        config_path = Path(config_file)
+
+        try:
+            with open(config_path) as f:
+                # Determine file format based on extension
+                if config_path.suffix.lower() in ['.yaml', '.yml']:
+                    config_raw = yaml.safe_load(f)
+                elif config_path.suffix.lower() == '.json':
+                    config_raw = json.load(f)
+                else:
+                    # Default to YAML if extension is not recognized
+                    config_raw = yaml.safe_load(f)
+
+            # Create config instance
+            config = cls(**config_raw)
+            # Store the config file path
+            cls._config_file = config_path
+
+            logger.info(f'Configuration loaded from {config_path}')
+            return config
+        except Exception as e:
+            logger.error(f'Failed to load configuration from {config_path}: {e}')
+            raise
+
+    def save(self, config_file: Optional[str | Path] = None) -> None:
+        """
+        Save the current configuration to a file.
+
+        Email and password values provided through environment variables
+        (AMSDAL_API_CHECK_EMAIL, AMSDAL_API_CHECK_PASSWORD) will not be saved to the file.
+        Only the token and other configuration values will be persisted.
+
+        Args:
+            config_file: Path to save the configuration to. If not provided,
+                         uses the path from which the config was loaded.
+        """
+        # Use provided path or fall back to the stored path
+        save_path = Path(config_file) if config_file else self.__class__._config_file
+
+        if not save_path:
+            logger.warning('No config file specified, cannot save configuration')
+            return
+
+        try:
+            # Convert config to dict
+            config_dict = self.model_dump()
+
+            # Don't save email and password if they were provided through environment variables
+            if self.env_email and self.email == self.env_email:
+                config_dict.pop('email', None)
+
+            if self.env_password and self.password == self.env_password:
+                config_dict.pop('password', None)
+
+            # No need to handle token and token_expiry as they are now properties
+            # and not included in the model_dump()
+
+            # Write to file
+            with open(save_path, 'w') as f:
+                json.dump(config_dict, f, indent=2)
+
+            logger.info(f'Configuration saved to {save_path}')
+        except Exception as e:
+            logger.error(f'Failed to save configuration: {e}')
+
+    # classes
+    exclude_classes: list[str] | Literal['ALL'] = Field(default_factory=list)
+
+    # objects
+    exclude_objects_for_classes: list[str] = Field(default_factory=list)
+    objects_list_params_options: list[dict[str, Any]] = Field(default_factory=list)
+    object_detail_params_options: list[dict[str, Any]] = Field(default_factory=list)
+    object_write_operations_enabled: bool = Field(default=False)
+    exclude_object_write_operations_for_classes: list[str] = Field(default_factory=list)
+    pre_object_create_hook: Callable[[dict[str, Any]], dict[str, Any]] | dict[str, Any] = Field(default_factory=dict)
+    pre_object_update_hook: Callable[[dict[str, Any]], dict[str, Any]] | dict[str, Any] = Field(default_factory=dict)
+
+    # transactions
+    ignore_transaction_execution_errors: bool = Field(default=True)
+    exclude_transactions: list[str] | Literal['ALL'] = Field(default_factory=list)
+    exclude_execute_transactions: list[str] | Literal['ALL'] = Field(default_factory=list)
+    transactions_data: list[TransactionData] = Field(default_factory=list)

amsdal_cli-0.5.3/src/amsdal_cli/commands/api_check/data_classes.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class ClassItem(BaseModel):
+    class_name: str
+    properties: list[dict[str, Any]]
+
+
+class Transaction(BaseModel):
+    title: str
+    properties: dict[str, Any]

amsdal_cli-0.5.3/src/amsdal_cli/commands/api_check/operation_log.py

@@ -0,0 +1,78 @@
+import base64
+import json
+import re
+from json import JSONEncoder
+from typing import Any
+
+from pydantic import BaseModel
+from pydantic import Field
+
+
+class BytesJSONEncoder(JSONEncoder):
+    def default(self, o: Any) -> Any:
+        if isinstance(o, bytes):
+            return base64.b64encode(o).decode('utf-8')
+        return super().default(o)
+
+
+class OperationLog(BaseModel):
+    method: str
+    uri: str
+    headers: dict[str, str] = Field(default_factory=dict)
+    params: dict[str, str] | None = None
+    data: Any
+    status_code: int
+    response_data: Any
+    response_headers: dict[str, str] = Field(default_factory=dict)
+
+    @property
+    def id(self) -> str:
+        _params = json.dumps(self.params, cls=BytesJSONEncoder) if self.params else None
+        _data = json.dumps(self.data, cls=BytesJSONEncoder) if self.data else None
+        return f'{self.method} {self.uri} {_params} {_data}'
+
+    def __str__(self) -> str:
+        _response = (
+            json.dumps(self.response_data, cls=BytesJSONEncoder) if not isinstance(self.response_data, str) else None
+        )
+
+        return f'{self.id} {self.status_code} {_response}'
+
+    @classmethod
+    def from_response(
+        cls,
+        response: Any,
+        auth_headers: dict[str, Any] | None = None,
+        *,
+        ignore_object_version: bool = False,
+        ignore_class_version: bool = False,
+    ) -> 'OperationLog':
+        request_headers = {key.lower(): value for key, value in response.request.headers.items()}
+
+        if auth_headers:
+            request_headers.update({key.lower(): '*****' for key in auth_headers})
+
+        return cls(
+            method=response.request.method,
+            uri=response.request.url.path,
+            headers=request_headers,
+            params=dict(response.request.url.params.items()),
+            data=response.request.content,
+            status_code=response.status_code,
+            response_data=cls._process_response_data(
+                response.text,
+                ignore_object_version=ignore_object_version,
+                ignore_class_version=ignore_class_version,
+            ),
+            response_headers=response.headers,
+        )
+
+    @classmethod
+    def _process_response_data(cls, text: str, *, ignore_object_version: bool, ignore_class_version: bool) -> Any:
+        if ignore_object_version:
+            text = re.sub(r'"object_version": "(?!(?:ALL|LATEST)\b).*?"', '"object_version": "ignore"', text)
+
+        if ignore_class_version:
+            text = re.sub(r'"class_version": "(?!(?:ALL|LATEST)\b).*?"', '"class_version": "ignore"', text)
+
+        return text