amsdal_cli 0.5.6__tar.gz → 0.5.8__tar.gz

{amsdal_cli-0.5.6 → amsdal_cli-0.5.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amsdal_cli
-Version: 0.5.6
+Version: 0.5.8
 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.5.6 → amsdal_cli-0.5.8}/change-logs.md

@@ -1,3 +1,15 @@
+## [v0.5.8](https://pypi.org/project/amsdal_cli/0.5.8/) - 2025-10-21
+
+### Added
+
+- External connections
+
+## [v0.5.7](https://pypi.org/project/amsdal_cli/0.5.7/) - 2025-09-02
+
+### Changed
+
+- Allow to specify source directory
+
 ## [v0.5.6](https://pypi.org/project/amsdal_cli/0.5.6/) - 2025-08-15
 
 ### Changed

amsdal_cli-0.5.8/latest-changelogs.md

@@ -0,0 +1,5 @@
+## [v0.5.8](https://pypi.org/project/amsdal_cli/0.5.8/) - 2025-10-21
+
+### Added
+
+- External connections

{amsdal_cli-0.5.6 → amsdal_cli-0.5.8}/src/amsdal_cli/__about__.py

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

{amsdal_cli-0.5.6 → amsdal_cli-0.5.8}/src/amsdal_cli/commands/build/schemas/loaders/base.py

@@ -81,7 +81,17 @@ class ConfigReaderMixin:
         """
         object_config = next(cls.read_configs_from_file(json_file))
 
-        return object_config.type != 'Fixture'
+        # Exclude fixtures
+        if object_config.type == 'Fixture':
+            return False
+
+        # Exclude external models (models with __connection__ attribute)
+        # Check model_extra (Pydantic v2) for extra fields
+        if hasattr(object_config, 'model_extra') and object_config.model_extra:
+            if '__connection__' in object_config.model_extra:
+                return False
+
+        return True
 
     @staticmethod
     def read_configs_from_file(json_file: Path) -> Iterator[ObjectSchema]:

{amsdal_cli-0.5.6 → amsdal_cli-0.5.8}/src/amsdal_cli/commands/build/services/builder.py

@@ -4,7 +4,6 @@ from typing import TYPE_CHECKING
 from rich import print as rprint
 
 from amsdal_cli.commands.build.services.mixin import BuildMixin
-from amsdal_cli.commands.generate.enums import SOURCES_DIR
 
 if TYPE_CHECKING:
     from amsdal_cli.utils.cli_config import CliConfig
@@ -15,7 +14,7 @@ class AppBuilder(BuildMixin):
         from amsdal_models.classes.class_manager import ClassManager
 
         self.cli_config = cli_config
-        self.source_path = cli_config.app_directory / SOURCES_DIR
+        self.source_path = cli_config.app_directory / cli_config.src_dir
         self.config_path = config_path
         self.class_manager = ClassManager()
 
@@ -39,6 +38,12 @@ class AppBuilder(BuildMixin):
             self.build_models(self.cli_config)
         elif (self.source_path / 'models').exists():
             self.copy_class_models(self.source_path / 'models')
+
+        # Copy external models if they exist
+        external_models_path = self.cli_config.app_directory / 'models' / 'external'
+        if external_models_path.exists():
+            self.copy_external_models(external_models_path)
+
         if not is_silent:
             rprint(rich_success('OK!'))
 

{amsdal_cli-0.5.6 → amsdal_cli-0.5.8}/src/amsdal_cli/commands/build/services/mixin.py

@@ -53,6 +53,31 @@ class BuildMixin:
             dirs_exist_ok=True,
         )
 
+    @staticmethod
+    def copy_external_models(external_models_path: Path) -> None:
+        """Copy external models to the build directory.
+
+        Args:
+            external_models_path: Path to the external models directory (e.g., models/external)
+        """
+        from amsdal.configs.main import settings
+
+        if not settings.USER_MODELS_MODULE_PATH:
+            return
+
+        # External models go to USER_MODELS_MODULE_PATH/external
+        target_path = settings.USER_MODELS_MODULE_PATH / 'external'
+
+        # Skip copy if source and target are the same (e.g., when building in place)
+        if external_models_path.resolve() == target_path.resolve():
+            return
+
+        shutil.copytree(
+            external_models_path,
+            target_path,
+            dirs_exist_ok=True,
+        )
+
     @staticmethod
     def build_transactions(cli_app_path: Path) -> None:
         """

{amsdal_cli-0.5.6 → amsdal_cli-0.5.8}/src/amsdal_cli/commands/cloud/deploy/sub_commands/deploy_new.py

@@ -70,7 +70,6 @@ async def _deploy(
 
     from amsdal_cli.commands.build.services.builder import AppBuilder
     from amsdal_cli.commands.cloud.environments.utils import get_current_env
-    from amsdal_cli.commands.generate.enums import SOURCES_DIR
     from amsdal_cli.utils.cli_config import CliConfig
     from amsdal_cli.utils.text import CustomConfirm
     from amsdal_cli.utils.text import rich_error
@@ -79,7 +78,7 @@ async def _deploy(
     from amsdal_cli.utils.text import rich_warning
 
     cli_config: CliConfig = ctx.meta['config']
-    app_source_path = cli_config.app_directory / SOURCES_DIR
+    app_source_path = cli_config.app_directory / cli_config.src_dir
     env_name = env_name or get_current_env(cli_config)
 
     if cli_config.verbose:

{amsdal_cli-0.5.6 → amsdal_cli-0.5.8}/src/amsdal_cli/commands/generate/enums.py

@@ -1,6 +1,5 @@
 from enum import Enum
 
-SOURCES_DIR = 'src'
 MODEL_JSON_FILE = 'model.json'
 MODEL_PY_FILE = 'model.py'
 FIXTURES_JSON_FILE = 'fixtures.json'

{amsdal_cli-0.5.6 → amsdal_cli-0.5.8}/src/amsdal_cli/commands/generate/sub_commands/__init__.py

@@ -1,3 +1,4 @@
+from amsdal_cli.commands.generate.sub_commands.generate_external_models import generate_external_models
 from amsdal_cli.commands.generate.sub_commands.generate_frontend_config import generate_frontend_config
 from amsdal_cli.commands.generate.sub_commands.generate_hook import generate_hook
 from amsdal_cli.commands.generate.sub_commands.generate_model import generate_model
@@ -8,6 +9,7 @@ from amsdal_cli.commands.generate.sub_commands.generate_tests import generate_te
 from amsdal_cli.commands.generate.sub_commands.generate_transaction import generate_transaction
 
 __all__ = [
+    'generate_external_models',
     'generate_frontend_config',
     'generate_hook',
     'generate_model',

amsdal_cli-0.5.8/src/amsdal_cli/commands/generate/sub_commands/generate_external_models.py

@@ -0,0 +1,365 @@
+"""Generate ExternalModel classes from external database connections."""
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+from typing import Any
+
+import typer
+
+from amsdal_cli.commands.generate.app import sub_app
+
+if TYPE_CHECKING:
+    from amsdal_cli.utils.cli_config import CliConfig
+
+
+@sub_app.command(name='external-models, ext-models, em')
+def generate_external_models(
+    ctx: typer.Context,
+    connection_name: str = typer.Argument(
+        ...,
+        help='The name of the external connection configured in config',
+    ),
+    output_dir: Path = typer.Option(  # noqa: B008
+        None,
+        '--output',
+        '-o',
+        help='Output directory for generated models (defaults to models/external/)',
+    ),
+    tables: list[str] = typer.Option(  # noqa: B008
+        None,
+        '--table',
+        '-t',
+        help='Specific table names to generate models for (generates all if not specified)',
+    ),
+    format_type: str = typer.Option(  # noqa: B008
+        'python',
+        '--format',
+        '-f',
+        help='Output format: "python" or "json"',
+    ),
+    schema: str | None = typer.Option(  # noqa: B008, ARG001
+        None,
+        '--schema',
+        '-s',
+        help='Database schema name (for databases that support schemas like PostgreSQL)',
+    ),
+) -> None:
+    """Generate ExternalModel classes from external database connections.
+
+    This command introspects an external database connection and generates
+    ExternalModel classes for the tables. The generated models can be used
+    immediately to query the external database.
+
+    **Examples:**
+
+    Generate models for all tables in an external connection:
+
+    ```bash
+    amsdal generate external-models my_external_db
+    ```
+
+    Generate models for specific tables only:
+
+    ```bash
+    amsdal generate external-models my_external_db -t users -t posts -t comments
+    ```
+
+    Generate models in JSON format:
+
+    ```bash
+    amsdal generate external-models my_external_db --format json
+    ```
+
+    Specify custom output directory:
+
+    ```bash
+    amsdal generate external-models my_external_db -o src/external_models
+    ```
+
+    Generate models for a specific PostgreSQL schema:
+
+    ```bash
+    amsdal generate external-models pg_db --schema public
+    ```
+
+    **Prerequisites:**
+
+    1. The external connection must be configured in your AMSDAL config
+    2. The connection must support schema introspection (SQLite, PostgreSQL)
+    3. The ExternalConnectionManager must be properly set up
+
+    **Generated Output:**
+
+    For Python format:
+    - Creates a module for each model: `models/external/{table_name}.py`
+    - Each module contains an ExternalModel class ready to use
+
+    For JSON format:
+    - Creates JSON schema files: `models/external/{table_name}/model.json`
+    - Can be loaded dynamically by AMSDAL framework
+    """
+    from amsdal.services.external_connections import ExternalConnectionManager
+    from amsdal.services.external_model_generator import ExternalModelGenerator
+    from amsdal_data.application import DataApplication
+    from amsdal_utils.config.manager import AmsdalConfigManager
+    from amsdal_utils.utils.text import to_snake_case
+
+    from amsdal_cli.utils.cli_config import CliConfig
+
+    cli_config: CliConfig = ctx.meta['config']
+
+    # Validate format
+    if format_type not in ('python', 'json'):
+        typer.echo(f"Error: Invalid format '{format_type}'. Must be 'python' or 'json'.", err=True)
+        raise typer.Exit(1)
+
+    # Set default output directory
+    if output_dir is None:
+        output_dir = Path.cwd() / 'models' / 'external'
+
+    # Ensure output directory exists
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Initialize AMSDAL components
+    config_manager = AmsdalConfigManager()
+    config = config_manager.get_config()
+
+    # Verify connection exists in config
+    if connection_name not in config.connections:
+        typer.echo(
+            f"Error: Connection '{connection_name}' not found in configuration.\n"
+            f'Available connections: {", ".join(config.connections.keys())}',
+            err=True,
+        )
+        raise typer.Exit(1)
+
+    # Initialize DataApplication
+    app = DataApplication()
+    app.setup(config)
+
+    # Initialize ExternalConnectionManager
+    manager = ExternalConnectionManager()
+    manager.setup(data_application=app)
+
+    # Initialize ExternalModelGenerator
+    generator = ExternalModelGenerator()
+
+    try:
+        # Generate models
+        typer.echo(f"Generating external models from connection '{connection_name}'...")
+
+        if tables:
+            typer.echo(f'Tables: {", ".join(tables)}')
+        else:
+            typer.echo('Generating models for all tables...')
+
+        models_dict = generator.generate_models_for_connection(
+            connection_name=connection_name,
+            table_names=tables if tables else None,
+        )
+
+        if not models_dict:
+            typer.echo('No tables found or no models generated.', err=True)
+            raise typer.Exit(1)
+
+        typer.echo(f'Successfully generated {len(models_dict)} model(s)')
+
+        # Write models to files
+        if format_type == 'python':
+            _write_python_models(models_dict, output_dir, cli_config)
+        else:
+            _write_json_models(models_dict, output_dir, cli_config, connection_name)
+
+        typer.echo(f'\nGenerated models written to: {output_dir}')
+        typer.echo('\nYou can now import and use these models:')
+        typer.echo('```python')
+        first_model = next(iter(models_dict.keys()))
+        typer.echo(f'from models.external.{to_snake_case(first_model)} import {first_model}')
+        typer.echo(f'{first_model}.objects.all().execute()')
+        typer.echo('```')
+
+    except ValueError as e:
+        typer.echo(f'Error: {e}', err=True)
+        raise typer.Exit(1) from e
+    except ConnectionError as e:
+        typer.echo(f'Connection error: {e}', err=True)
+        raise typer.Exit(1) from e
+    except Exception as e:
+        typer.echo(f'Unexpected error: {e}', err=True)
+        raise typer.Exit(1) from e
+    finally:
+        # Clean up
+        app.teardown()
+        ExternalConnectionManager.invalidate()
+        AmsdalConfigManager.invalidate()
+        DataApplication.invalidate()
+
+
+def _write_python_models(
+    models_dict: dict[str, type],
+    output_dir: Path,
+    cli_config: 'CliConfig',  # noqa: F821
+) -> None:
+    """Write generated models as Python files."""
+    from amsdal_utils.utils.text import to_snake_case
+
+    # Create __init__.py for the package
+    init_file = output_dir / '__init__.py'
+    init_file.touch(exist_ok=True)
+
+    # Write each model to a separate file
+    for model_name, model_class in models_dict.items():
+        module_name = to_snake_case(model_name)
+        file_path = output_dir / f'{module_name}.py'
+
+        # Generate the model file content
+        content = _generate_python_model_content(model_class, cli_config)
+
+        # Write to file
+        file_path.write_text(content)
+        typer.echo(f'  ✓ {module_name}.py')
+
+
+def _generate_python_model_content(model_class: type, cli_config: 'CliConfig') -> str:  # noqa: F821
+    """Generate Python code for an ExternalModel class."""
+    model_name = model_class.__name__
+    table_name = model_class.__table_name__  # type: ignore[attr-defined]
+    connection = model_class.__connection__  # type: ignore[attr-defined]
+
+    # Get annotations
+    annotations = getattr(model_class, '__annotations__', {})
+
+    # Build imports
+    imports = {'from amsdal_models.classes.external_model import ExternalModel'}
+
+    # Build field definitions
+    field_lines = []
+    indent = ' ' * cli_config.indent
+
+    for field_name, field_type in annotations.items():
+        type_str = _get_type_annotation(field_type)
+        field_lines.append(f'{indent}{field_name}: {type_str}')
+
+    # Build class definition
+    lines = [
+        '"""',
+        f'External model for {table_name} table.',
+        '',
+        f'Generated from external connection: {connection}',
+        '"""',
+        '',
+        *sorted(imports),
+        '',
+        '',
+        f'class {model_name}(ExternalModel):',
+        f'{indent}"""External model for {table_name}."""',
+        '',
+        f"{indent}__table_name__ = '{table_name}'",
+        f"{indent}__connection__ = '{connection}'",
+    ]
+
+    # Add primary key if present
+    if hasattr(model_class, '__primary_key__'):
+        pk = model_class.__primary_key__
+        if isinstance(pk, list):
+            lines.append(f'{indent}__primary_key__ = {pk!r}')
+        else:
+            lines.append(f"{indent}__primary_key__ = '{pk}'")
+
+    # Add field definitions
+    if field_lines:
+        lines.append('')
+        lines.extend(field_lines)
+
+    return '\n'.join(lines) + '\n'
+
+
+def _get_type_annotation(python_type: type) -> str:
+    """Convert Python type to string annotation."""
+    type_mapping = {
+        str: 'str',
+        int: 'int',
+        float: 'float',
+        bool: 'bool',
+        bytes: 'bytes',
+        list: 'list',
+        dict: 'dict',
+    }
+
+    return type_mapping.get(python_type, 'str')
+
+
+def _write_json_models(
+    models_dict: dict[str, type],
+    output_dir: Path,
+    cli_config: 'CliConfig',  # noqa: F821
+    connection_name: str,
+) -> None:
+    """Write generated models as JSON schema files."""
+    import json
+
+    from amsdal_utils.utils.text import to_snake_case
+
+    for model_name, model_class in models_dict.items():
+        module_name = to_snake_case(model_name)
+        model_dir = output_dir / module_name
+        model_dir.mkdir(exist_ok=True, parents=True)
+
+        json_file = model_dir / 'model.json'
+
+        # Build JSON schema
+        schema = _generate_json_schema(model_class, connection_name)
+
+        # Write to file
+        json_file.write_text(json.dumps(schema, indent=cli_config.indent, ensure_ascii=False))
+        typer.echo(f'  ✓ {module_name}/model.json')
+
+
+def _generate_json_schema(model_class: type, connection_name: str) -> dict[str, Any]:
+    """Generate JSON schema for an ExternalModel class."""
+    model_name = model_class.__name__
+    table_name = model_class.__table_name__  # type: ignore[attr-defined]
+    annotations = getattr(model_class, '__annotations__', {})
+
+    # Build properties
+    properties = {}
+    for field_name, field_type in annotations.items():
+        properties[field_name] = {
+            'type': _python_type_to_json_type(field_type),
+            'title': field_name,
+        }
+
+    schema: dict[str, Any] = {
+        'title': model_name,
+        'type': 'object',
+        'properties': properties,
+        '__table_name__': table_name,
+        '__connection__': connection_name,
+    }
+
+    # Add primary key if present
+    if hasattr(model_class, '__primary_key__'):
+        pk = model_class.__primary_key__
+        if isinstance(pk, str):
+            schema['__primary_key__'] = [pk]
+        else:
+            schema['__primary_key__'] = list(pk)
+
+    return schema
+
+
+def _python_type_to_json_type(python_type: type) -> str:
+    """Convert Python type to JSON schema type string."""
+    from amsdal_utils.models.data_models.enums import CoreTypes
+
+    type_mapping = {
+        str: CoreTypes.STRING.value,
+        int: CoreTypes.INTEGER.value,
+        float: CoreTypes.NUMBER.value,
+        bool: CoreTypes.BOOLEAN.value,
+        bytes: CoreTypes.BINARY.value,
+        list: CoreTypes.ARRAY.value,
+        dict: CoreTypes.DICTIONARY.value,
+    }
+
+    return type_mapping.get(python_type, CoreTypes.STRING.value)

{amsdal_cli-0.5.6 → amsdal_cli-0.5.8}/src/amsdal_cli/commands/generate/sub_commands/generate_model.py

@@ -75,7 +75,6 @@ def generate_model(
     from amsdal_utils.utils.text import to_snake_case
 
     from amsdal_cli.commands.generate.enums import MODEL_JSON_FILE
-    from amsdal_cli.commands.generate.enums import SOURCES_DIR
     from amsdal_cli.commands.generate.utils.model_attributes import parse_attributes
     from amsdal_cli.utils.cli_config import CliConfig
     from amsdal_cli.utils.cli_config import ModelsFormat
@@ -122,7 +121,7 @@ def generate_model(
         json_schema['properties'][attr.name] = property_info
 
     if cli_config.models_format == ModelsFormat.JSON:
-        output_path = cli_config.app_directory / SOURCES_DIR / 'models' / name
+        output_path = cli_config.app_directory / cli_config.src_dir / 'models' / name
 
         write_file(
             json.dumps(json_schema, indent=cli_config.indent),
@@ -138,11 +137,11 @@ def generate_model(
 
         from amsdal_cli.utils.schema_repository import build_schema_repository
 
-        output_path = cli_config.app_directory / SOURCES_DIR / 'models'
+        output_path = cli_config.app_directory / cli_config.src_dir / 'models'
         output_path.mkdir(exist_ok=True, parents=True)
         (output_path / '__init__.py').touch(exist_ok=True)
 
-        sys.path.insert(0, str((cli_config.app_directory / SOURCES_DIR).absolute()))
+        sys.path.insert(0, str((cli_config.app_directory / cli_config.src_dir).absolute()))
 
         schema_repository = build_schema_repository(cli_config=cli_config)
         class_builder = ClassBuilder()

{amsdal_cli-0.5.6 → amsdal_cli-0.5.8}/src/amsdal_cli/commands/generate/sub_commands/generate_permission.py

@@ -24,7 +24,6 @@ def generate_permission(
     from amsdal_utils.utils.text import to_snake_case
 
     from amsdal_cli.commands.generate.enums import FIXTURES
-    from amsdal_cli.commands.generate.enums import SOURCES_DIR
     from amsdal_cli.utils.cli_config import CliConfig
     from amsdal_cli.utils.copier import write_file
 
@@ -57,7 +56,7 @@ def generate_permission(
                 }
             )
 
-    base_path = cli_config.app_directory / SOURCES_DIR
+    base_path = cli_config.app_directory / cli_config.src_dir
     (base_path / FIXTURES).mkdir(parents=True, exist_ok=True)
     permissions_file = base_path / FIXTURES / f'{model_snake_case}_permissions.json'
 

{amsdal_cli-0.5.6 → amsdal_cli-0.5.8}/src/amsdal_cli/commands/generate/sub_commands/generate_tests.py

@@ -68,7 +68,6 @@ async def _generate_tests(
     from amsdal.manager import AmsdalManager
     from amsdal.manager import AsyncAmsdalManager
 
-    from amsdal_cli.commands.generate.enums import SOURCES_DIR
     from amsdal_cli.commands.generate.utils.tests.conftest_utils import create_conftest_if_not_exist
     from amsdal_cli.commands.generate.utils.tests.unit import generate_and_save_unit_tests
     from amsdal_cli.commands.serve.utils import async_build_app_and_check_migrations
@@ -88,7 +87,7 @@ async def _generate_tests(
     config_manager.load_config(config_path)
 
     create_conftest_if_not_exist(cli_config)
-    app_source_path = cli_config.app_directory / SOURCES_DIR
+    app_source_path = cli_config.app_directory / cli_config.src_dir
 
     manager: AmsdalManager | AsyncAmsdalManager
     if config_manager.get_config().async_mode:

{amsdal_cli-0.5.6 → amsdal_cli-0.5.8}/src/amsdal_cli/commands/generate/sub_commands/generate_transaction.py

@@ -21,14 +21,13 @@ def generate_transaction(
     from amsdal_utils.utils.text import classify
     from amsdal_utils.utils.text import to_snake_case
 
-    from amsdal_cli.commands.generate.enums import SOURCES_DIR
     from amsdal_cli.utils.cli_config import CliConfig
     from amsdal_cli.utils.copier import copy_blueprint
 
     cli_config: CliConfig = ctx.meta['config']
     config_path = cli_config.config_path
     name = to_snake_case(transaction_name)
-    output_path = cli_config.app_directory / SOURCES_DIR / 'transactions'
+    output_path = cli_config.app_directory / cli_config.src_dir / 'transactions'
     config_manager = AmsdalConfigManager()
     config_manager.load_config(config_path)
 

{amsdal_cli-0.5.6 → amsdal_cli-0.5.8}/src/amsdal_cli/commands/generate/utils/build_base_path.py

@@ -3,7 +3,6 @@ from pathlib import Path
 import typer
 from rich import print as rprint
 
-from amsdal_cli.commands.generate.enums import SOURCES_DIR
 from amsdal_cli.utils.cli_config import CliConfig
 from amsdal_cli.utils.text import rich_error
 
@@ -23,7 +22,7 @@ def build_model_base_path(ctx: typer.Context, model_name: str) -> Path:
 
     cli_config: CliConfig = ctx.meta['config']
     model = to_snake_case(model_name)
-    model_path = cli_config.app_directory / SOURCES_DIR / 'models' / model
+    model_path = cli_config.app_directory / cli_config.src_dir / 'models' / model
 
     if cli_config.check_model_exists and not (
         (model_path / 'model.json').exists() or (model_path / 'model.py').exists()

{amsdal_cli-0.5.6 → amsdal_cli-0.5.8}/src/amsdal_cli/commands/generate/utils/tests/conftest_utils.py

@@ -2,14 +2,13 @@ from pathlib import Path
 
 from amsdal_utils.config.manager import AmsdalConfigManager
 
-from amsdal_cli.commands.generate.enums import SOURCES_DIR
 from amsdal_cli.utils.cli_config import CliConfig
 
 CURRENT_DIR = Path(__file__).parent
 
 
 def create_conftest_if_not_exist(cli_config: CliConfig) -> None:
-    test_dir = cli_config.app_directory / SOURCES_DIR / 'tests'
+    test_dir = cli_config.app_directory / cli_config.src_dir / 'tests'
     test_dir.mkdir(parents=True, exist_ok=True)
     conftest_file_path = test_dir / 'conftest.py'
 

{amsdal_cli-0.5.6 → amsdal_cli-0.5.8}/src/amsdal_cli/commands/generate/utils/tests/unit.py

@@ -11,7 +11,6 @@ from amsdal_utils.utils.text import classify
 from amsdal_utils.utils.text import to_snake_case
 from black.mode import TargetVersion
 
-from amsdal_cli.commands.generate.enums import SOURCES_DIR
 from amsdal_cli.commands.generate.enums import TestDataType
 from amsdal_cli.commands.generate.utils.tests.async_mode_utils import maybe_await
 from amsdal_cli.commands.generate.utils.tests.function_utils import test_function_arguments
@@ -581,7 +580,7 @@ def generate_unit_tests(
     cli_config: CliConfig,
     test_data_type: TestDataType,
 ) -> str:
-    models_dir = cli_config.app_directory / SOURCES_DIR / 'models'
+    models_dir = cli_config.app_directory / cli_config.src_dir / 'models'
 
     object_schema = get_class_schema(models_dir, model_name, cli_config)
 
@@ -661,7 +660,7 @@ def generate_and_save_unit_tests(
     model_name = classify(model_name)
     model_name_snake_case = to_snake_case(model_name)
 
-    unit_test_dir = cli_config.app_directory / SOURCES_DIR / 'tests' / 'unit'
+    unit_test_dir = cli_config.app_directory / cli_config.src_dir / 'tests' / 'unit'
     unit_test_dir.mkdir(parents=True, exist_ok=True)
 
     filename = f'test_{model_name_snake_case}.py'