polylith-cli 1.2.0__tar.gz → 1.3.0__tar.gz

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: polylith-cli
-Version: 1.2.0
+Version: 1.3.0
 Summary: Python tooling support for the Polylith Architecture
 Home-page: https://davidvujic.github.io/python-polylith-docs/
 License: MIT

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/polylith_cli/polylith/bricks/brick.py

@@ -1,19 +1,19 @@
 from pathlib import Path
+from polylith_cli.polylith import configuration
 from polylith_cli.polylith.dirs import create_dir
 from polylith_cli.polylith.files import create_file
 from polylith_cli.polylith.interface import create_interface
 from polylith_cli.polylith.readme import create_brick_readme
-from polylith_cli.polylith.workspace import parser
 
 def create_brick(root: Path, options: dict) -> None:
     modulename = options['modulename']
     path_kwargs = {k: v for k, v in options.items() if k in {'brick', 'namespace', 'package'}}
-    brick_structure = parser.get_brick_structure_from_config(root)
-    resources_structure = parser.get_resources_structure_from_config(root)
+    brick_structure = configuration.get_brick_structure_from_config(root)
+    resources_structure = configuration.get_resources_structure_from_config(root)
     brick_path = brick_structure.format(**path_kwargs)
     resources_path = resources_structure.format(**path_kwargs)
     d = create_dir(root, brick_path)
     create_file(d, f'{modulename}.py')
     create_interface(d, options)
-    if parser.is_readme_generation_enabled(root):
+    if configuration.is_readme_generation_enabled(root):
         create_brick_readme(root / resources_path, options)

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/polylith_cli/polylith/bricks/component.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 from typing import List
-from polylith_cli.polylith import workspace
+from polylith_cli.polylith import configuration
 from polylith_cli.polylith.bricks.brick import create_brick
 from polylith_cli.polylith.repo import components_dir
 from polylith_cli.polylith.test import create_test
@@ -15,7 +15,7 @@ def is_brick_dir(p: Path) -> bool:
     return p.is_dir() and p.name not in {'__pycache__', '.venv', '.mypy_cache'}
 
 def get_component_dirs(root: Path, top_dir, ns) -> list:
-    theme = workspace.parser.get_theme_from_config(root)
+    theme = configuration.get_theme_from_config(root)
     dirs = top_dir if theme == 'tdd' else f'{top_dir}/{ns}'
     component_dir = root / dirs
     if not component_dir.exists():

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/polylith_cli/polylith/check/collect.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import List, Set
+from typing import Set
 from polylith_cli.polylith import check, imports, workspace
 
 def extract_bricks(paths: Set[Path], ns: str) -> dict:
@@ -19,11 +19,11 @@ def with_unknown_components(root: Path, ns: str, brick_imports: dict) -> dict:
     collected = {**brick_imports, **extracted}
     return with_unknown_components(root, ns, collected)
 
-def diff(known_bricks: Set[str], bases: List[str], components: List[str]) -> Set[str]:
+def diff(known_bricks: Set[str], bases: Set[str], components: Set[str]) -> Set[str]:
     bricks = set().union(bases, components)
     return known_bricks.difference(bricks)
 
-def imports_diff(brick_imports: dict, bases: List, components: List) -> Set[str]:
+def imports_diff(brick_imports: dict, bases: Set[str], components: Set[str]) -> Set[str]:
     flattened_bases = set().union(*brick_imports['bases'].values())
     flattened_components = set().union(*brick_imports['components'].values())
     flattened_imports = set().union(flattened_bases, flattened_components)

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/polylith_cli/polylith/check/report.py

@@ -42,6 +42,6 @@ def create_report(project_data: dict, collected_imports: dict, third_party_libs:
     components = {c for c in project_data.get('components', [])}
     brick_imports = collected_imports['brick_imports']
     third_party_imports = collected_imports['third_party_imports']
-    brick_diff = collect.imports_diff(brick_imports, list(bases), list(components))
+    brick_diff = collect.imports_diff(brick_imports, bases, components)
     libs_diff = libs.report.calculate_diff(third_party_imports, third_party_libs, is_strict)
     return {'brick_imports': brick_imports, 'third_party_imports': third_party_imports, 'brick_diff': brick_diff, 'libs_diff': libs_diff}

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/polylith_cli/polylith/cli/core.py

@@ -1,11 +1,16 @@
 from pathlib import Path
-from polylith_cli.polylith import commands, info, repo, workspace
+from typing import List, Union
+from polylith_cli.polylith import commands, configuration, info, repo
 from polylith_cli.polylith.cli import create, options
 from typer import Exit, Option, Typer
 from typing_extensions import Annotated
 app = Typer()
 app.add_typer(create.app, name='create', help='Commands for creating a workspace, bases, components and projects.')
 
+def filtered_projects_data(projects_data: List[dict], directory: Union[str, None]) -> List[dict]:
+    dir_path = Path(directory).as_posix() if directory else Path.cwd().name
+    return [p for p in projects_data if dir_path in p['path'].as_posix()]
+
 @app.command('info')
 def info_command(short: Annotated[bool, options.short_workspace]=False):
     """Info about the Polylith workspace."""
@@ -15,12 +20,11 @@ def info_command(short: Annotated[bool, options.short_workspace]=False):
 def check_command(strict: Annotated[bool, options.strict]=False, verbose: Annotated[bool, options.verbose]=False, quiet: Annotated[bool, options.quiet]=False, directory: Annotated[str, options.directory]='', alias: Annotated[str, options.alias]=''):
     """Validates the Polylith workspace."""
     root = repo.get_workspace_root(Path.cwd())
-    ns = workspace.parser.get_namespace_from_config(root)
+    ns = configuration.get_namespace_from_config(root)
     all_projects_data = info.get_projects_data(root, ns)
     only_projects_data = [p for p in all_projects_data if info.is_project(p)]
     cli_options = {'verbose': verbose, 'quiet': quiet, 'strict': strict, 'alias': str.split(alias, ',') if alias else []}
-    dir_path = Path(directory).as_posix() if directory else Path.cwd().name
-    projects_data = [p for p in only_projects_data if dir_path in p['path'].as_posix()]
+    projects_data = filtered_projects_data(only_projects_data, directory)
     results = {commands.check.run(root, ns, p, cli_options) for p in projects_data}
     if not all(results):
         raise Exit(code=1)
@@ -34,11 +38,10 @@ def diff_command(since: Annotated[str, Option(help='Changed since a specific tag
 def libs_command(strict: Annotated[bool, options.strict]=False, directory: Annotated[str, options.directory]='', alias: Annotated[str, options.alias]=''):
     """Show third-party libraries used in the workspace."""
     root = repo.get_workspace_root(Path.cwd())
-    ns = workspace.parser.get_namespace_from_config(root)
-    projects_data = info.get_projects_data(root, ns)
+    ns = configuration.get_namespace_from_config(root)
+    all_projects_data = info.get_projects_data(root, ns)
     cli_options = {'strict': strict, 'alias': str.split(alias, ',') if alias else []}
-    dir_path = Path(directory).as_posix() if directory else Path.cwd().name
-    projects_data = [p for p in projects_data if dir_path in p['path'].as_posix()]
+    projects_data = filtered_projects_data(all_projects_data, directory)
     results = {commands.libs.run(root, ns, p, cli_options) for p in projects_data}
     if not all(results):
         raise Exit(code=1)
@@ -47,12 +50,19 @@ def libs_command(strict: Annotated[bool, options.strict]=False, directory: Annot
 def sync_command(strict: Annotated[bool, options.strict]=False, quiet: Annotated[bool, options.quiet]=False, directory: Annotated[str, options.directory]='', verbose: Annotated[str, options.verbose]=''):
     """Update pyproject.toml with missing bricks."""
     root = repo.get_workspace_root(Path.cwd())
-    ns = workspace.parser.get_namespace_from_config(root)
-    projects_data = info.get_projects_data(root, ns)
+    ns = configuration.get_namespace_from_config(root)
+    all_projects_data = info.get_projects_data(root, ns)
     cli_options = {'strict': strict, 'quiet': quiet, 'verbose': verbose}
-    dir_path = Path(directory).as_posix() if directory else Path.cwd().name
-    projects_data = [p for p in projects_data if dir_path in p['path'].as_posix()]
+    projects_data = filtered_projects_data(all_projects_data, directory)
     for p in projects_data:
         commands.sync.run(root, ns, p, cli_options)
+
+@app.command('deps')
+def deps_command(directory: Annotated[str, options.directory]=''):
+    """Visualize the dependencies between bricks."""
+    root = repo.get_workspace_root(Path.cwd())
+    ns = configuration.get_namespace_from_config(root)
+    dir_path = Path(directory).as_posix() if directory else None
+    commands.deps.run(root, ns, dir_path)
 if __name__ == '__main__':
     app()

polylith_cli-1.3.0/polylith_cli/polylith/commands/__init__.py

@@ -0,0 +1,2 @@
+from polylith_cli.polylith.commands import check, create, deps, diff, info, libs, sync
+__all__ = ['check', 'create', 'deps', 'diff', 'info', 'libs', 'sync']

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/polylith_cli/polylith/commands/create.py

@@ -1,10 +1,10 @@
 from pathlib import Path
 from typing import Union
-from polylith_cli.polylith import repo, workspace
+from polylith_cli.polylith import configuration, repo
 
 def create(name: Union[str, None], description: Union[str, None], fn):
     root = repo.get_workspace_root(Path.cwd())
-    namespace = workspace.parser.get_namespace_from_config(root)
+    namespace = configuration.get_namespace_from_config(root)
     if not name:
         raise ValueError('Please add a name by using --name')
     if not namespace:

polylith_cli-1.3.0/polylith_cli/polylith/commands/deps.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+from typing import List, Set, Union
+from polylith_cli.polylith import bricks, deps, info
+
+def print_report(root: Path, ns: str, bases: Set[str], components: Set[str]):
+    brick_imports = deps.get_brick_imports(root, ns, bases, components)
+    flattened = {**brick_imports['bases'], **brick_imports['components']}
+    deps.print_deps(bases, components, flattened)
+
+def pick_name(data: List[dict]) -> Set[str]:
+    return {b['name'] for b in data}
+
+def get_bases(root: Path, ns: str, project_data: dict) -> Set[str]:
+    if project_data:
+        return set(project_data.get('bases', []))
+    return pick_name(bricks.get_bases_data(root, ns))
+
+def get_components(root: Path, ns: str, project_data: dict) -> Set[str]:
+    if project_data:
+        return set(project_data.get('components', []))
+    return pick_name(bricks.get_components_data(root, ns))
+
+def run(root: Path, ns: str, directory: Union[str, None]):
+    projects_data = info.get_projects_data(root, ns) if directory else []
+    project = next((p for p in projects_data if directory in p['path'].as_posix()), {})
+    bases = get_bases(root, ns, project)
+    components = get_components(root, ns, project)
+    print_report(root, ns, bases, components)

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/polylith_cli/polylith/commands/diff.py

@@ -1,9 +1,9 @@
 from pathlib import Path
 from typing import Union
-from polylith_cli.polylith import diff, info, repo, workspace
+from polylith_cli.polylith import configuration, diff, info, repo
 
 def print_views(root: Path, tag: str, short: bool, only_bricks: bool) -> None:
-    ns = workspace.parser.get_namespace_from_config(root)
+    ns = configuration.get_namespace_from_config(root)
     files = diff.collect.get_files(tag)
     bases = diff.collect.get_changed_bases(files, ns)
     components = diff.collect.get_changed_components(files, ns)

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/polylith_cli/polylith/commands/info.py

@@ -1,9 +1,9 @@
 from pathlib import Path
-from polylith_cli.polylith import info, repo, workspace
+from polylith_cli.polylith import configuration, info, repo
 
 def run(short: bool):
     root = repo.get_workspace_root(Path.cwd())
-    ns = workspace.parser.get_namespace_from_config(root)
+    ns = configuration.get_namespace_from_config(root)
     bases = info.get_bases(root, ns)
     components = info.get_components(root, ns)
     projects_data = info.get_bricks_in_projects(root, components, bases, ns)

polylith_cli-1.3.0/polylith_cli/polylith/configuration/__init__.py

@@ -0,0 +1,2 @@
+from polylith_cli.polylith.configuration.core import get_brick_structure_from_config, get_namespace_from_config, get_resources_structure_from_config, get_tag_pattern_from_config, get_tests_structure_from_config, get_theme_from_config, is_readme_generation_enabled, is_test_generation_enabled
+__all__ = ['get_brick_structure_from_config', 'get_namespace_from_config', 'get_resources_structure_from_config', 'get_tag_pattern_from_config', 'get_tests_structure_from_config', 'get_theme_from_config', 'is_readme_generation_enabled', 'is_test_generation_enabled']

polylith_cli-1.3.0/polylith_cli/polylith/deps/__init__.py

@@ -0,0 +1,3 @@
+from polylith_cli.polylith.deps.core import get_brick_imports
+from polylith_cli.polylith.deps.report import print_deps
+__all__ = ['get_brick_imports', 'print_deps']

polylith_cli-1.3.0/polylith_cli/polylith/deps/core.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+from typing import Set
+from polylith_cli.polylith import check, workspace
+
+def get_brick_imports(root: Path, ns: str, bases: Set[str], components: Set[str]) -> dict:
+    bases_paths = workspace.paths.collect_bases_paths(root, ns, bases)
+    comp_paths = workspace.paths.collect_components_paths(root, ns, components)
+    brick_imports_in_bases = check.collect.extract_bricks(bases_paths, ns)
+    brick_imports_in_components = check.collect.extract_bricks(comp_paths, ns)
+    return {'bases': check.collect.with_unknown_components(root, ns, brick_imports_in_bases), 'components': check.collect.with_unknown_components(root, ns, brick_imports_in_components)}

polylith_cli-1.3.0/polylith_cli/polylith/deps/report.py

@@ -0,0 +1,57 @@
+from functools import reduce
+from typing import List, Set, Tuple
+from polylith_cli.polylith.reporting import theme
+from rich import box
+from rich.console import Console
+from rich.table import Table
+
+def calculate_tag(brick: str, project_data: dict) -> str:
+    return 'base' if brick in project_data.get('bases', []) else 'comp'
+
+def to_col(brick: str, tag: str) -> str:
+    name = '\n'.join(brick)
+    return f'[{tag}]{name}[/]'
+
+def brick_status(bricks: List[str], brick_name: str, imported: str) -> str:
+    status = theme.check_emoji if imported in bricks and imported != brick_name else '-'
+    return f'[data]{status}[/]'
+
+def to_row(name: str, tag: str, brick_imports: dict, imported: List[str]) -> List[str]:
+    bricks = brick_imports[name]
+    statuses = [brick_status(bricks, name, i) for i in imported]
+    return [f'[{tag}]{name}[/]'] + statuses
+
+def flatten_import(acc: Set[str], kv: Tuple[str, Set[str]]) -> set:
+    key = kv[0]
+    values = kv[1]
+    return set().union(acc, values.difference({key}))
+
+def flatten_imports(brick_imports: dict) -> Set[str]:
+    """Flatten the dict into a set of imports, with the actual brick filtered away when existing as an import"""
+    return reduce(flatten_import, brick_imports.items(), set())
+
+def create_columns(imported_bases: List[str], imported_components: List[str]) -> List[str]:
+    base_cols = [to_col(brick, 'base') for brick in imported_bases]
+    comp_cols = [to_col(brick, 'comp') for brick in imported_components]
+    return comp_cols + base_cols
+
+def create_rows(bases: Set[str], components: Set[str], import_data: dict, imported: List[str]) -> List[List[str]]:
+    base_rows = [to_row(b, 'base', import_data, imported) for b in sorted(bases)]
+    comp_rows = [to_row(c, 'comp', import_data, imported) for c in sorted(components)]
+    return comp_rows + base_rows
+
+def print_deps(bases: Set[str], components: Set[str], import_data: dict):
+    flattened = flatten_imports(import_data)
+    imported_bases = sorted({b for b in flattened if b in bases})
+    imported_components = sorted({c for c in flattened if c in components})
+    imported_bricks = imported_components + imported_bases
+    table = Table(box=box.SIMPLE_HEAD)
+    table.add_column('[data]brick[/]')
+    cols = create_columns(imported_bases, imported_components)
+    rows = create_rows(bases, components, import_data, imported_bricks)
+    for col in cols:
+        table.add_column(col, justify='center')
+    for row in rows:
+        table.add_row(*row)
+    console = Console(theme=theme.poly_theme)
+    console.print(table, overflow='ellipsis')

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/polylith_cli/polylith/diff/collect.py

@@ -1,7 +1,7 @@
 import subprocess
 from pathlib import Path
 from typing import List, Set, Union
-from polylith_cli.polylith import repo, workspace
+from polylith_cli.polylith import configuration, repo
 
 def _parse_folder_parts(folder: str, changed_file: Path) -> str:
     file_path = Path(changed_file.as_posix().replace(folder, ''))
@@ -26,7 +26,7 @@ def get_changed_projects(changed_files: List[Path]) -> list:
     return sorted(filtered)
 
 def get_latest_tag(root: Path, key: Union[str, None]) -> Union[str, None]:
-    tag_pattern = workspace.parser.get_tag_pattern_from_config(root, key)
+    tag_pattern = configuration.get_tag_pattern_from_config(root, key)
     res = subprocess.run(['git', 'tag', '-l', '--sort=-committerdate', f'{tag_pattern}'], capture_output=True)
     return next((tag for tag in res.stdout.decode('utf-8').split()), None)
 

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/polylith_cli/polylith/info/report.py

@@ -6,7 +6,7 @@ from rich.padding import Padding
 from rich.table import Table
 
 def brick_status(brick, bricks, command: str) -> str:
-    emoji = ':heavy_check_mark:' if command == 'info' else ':gear:'
+    emoji = theme.check_emoji if command == 'info' else ':gear:'
     status = emoji if brick in bricks else '-'
     return f'[data]{status}[/]'
 

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/polylith_cli/polylith/libs/grouping.py

@@ -1,7 +1,7 @@
 import sys
 from pathlib import Path
 from typing import Set
-from polylith_cli.polylith import workspace
+from polylith_cli.polylith import configuration
 from polylith_cli.polylith.imports import extract_top_ns, fetch_all_imports
 from polylith_cli.polylith.libs.stdlib import standard_libs
 
@@ -30,6 +30,6 @@ def extract_third_party_imports(all_imports: dict, top_ns: str) -> dict:
     return exclude_empty(with_third_party)
 
 def get_third_party_imports(root: Path, paths: Set[Path]) -> dict:
-    top_ns = workspace.parser.get_namespace_from_config(root)
+    top_ns = configuration.get_namespace_from_config(root)
     all_imports = fetch_all_imports(paths)
     return extract_third_party_imports(all_imports, top_ns)

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/polylith_cli/polylith/project/get.py

@@ -2,7 +2,7 @@ from functools import lru_cache
 from pathlib import Path
 from typing import List
 import tomlkit
-from polylith_cli.polylith import repo, toml, workspace
+from polylith_cli.polylith import configuration, repo, toml
 
 def get_project_name(data) -> str:
     if repo.is_pep_621_ready(data):
@@ -31,5 +31,5 @@ def get_toml_files(root: Path) -> List[dict]:
 
 def get_packages_for_projects(root: Path) -> List[dict]:
     toml_files = get_toml_files(root)
-    namespace = workspace.parser.get_namespace_from_config(root)
+    namespace = configuration.get_namespace_from_config(root)
     return [{'name': get_project_name(d['toml']), 'packages': toml.get_project_package_includes(namespace, d['toml']), 'path': d['path'], 'type': d['type'], 'deps': toml.get_project_dependencies(d['toml'])} for d in toml_files]

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/polylith_cli/polylith/reporting/theme.py

@@ -8,3 +8,5 @@ poly_theme = Theme(
         "base": "#6495ED",
     }
 )
+
+check_emoji = ":heavy_check_mark:"

polylith_cli-1.3.0/polylith_cli/polylith/sync/collect.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+from polylith_cli.polylith import check, deps, info
+
+def calculate_diff(root: Path, namespace: str, project_data: dict, workspace_data: dict) -> dict:
+    bases = set(project_data['bases'])
+    components = set(project_data['components'])
+    all_bases = workspace_data['bases']
+    all_components = workspace_data['components']
+    brick_imports = deps.get_brick_imports(root, namespace, bases, components)
+    is_project = info.is_project(project_data)
+    if is_project:
+        brick_diff = check.collect.imports_diff(brick_imports, bases, components)
+    else:
+        all_bricks = set().union(all_bases, all_components)
+        brick_diff = check.collect.diff(all_bricks, bases, components)
+    bases_diff = {b for b in brick_diff if b in all_bases}
+    components_diff = {b for b in brick_diff if b in all_components}
+    return {'name': project_data['name'], 'path': project_data['path'], 'is_project': is_project, 'bases': bases_diff, 'components': components_diff, 'brick_imports': brick_imports}

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/polylith_cli/polylith/sync/report.py

@@ -13,7 +13,7 @@ def print_summary(diff: dict) -> None:
     bases = diff['bases']
     components = diff['components']
     anything_to_sync = bases or components
-    emoji = ':point_right:' if anything_to_sync else ':heavy_check_mark:'
+    emoji = ':point_right:' if anything_to_sync else theme.check_emoji
     printable_name = f'[proj]{name}[/]' if is_project else f'[data]{name}[/]'
     console.print(f'{emoji} {printable_name}')
     for b in bases:

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/polylith_cli/polylith/sync/update.py

@@ -2,7 +2,7 @@ from functools import reduce
 from pathlib import Path
 from typing import List, Union
 import tomlkit
-from polylith_cli.polylith import project, repo, workspace
+from polylith_cli.polylith import configuration, project, repo
 from tomlkit.toml_document import TOMLDocument
 
 def to_package(namespace: str, brick: str, brick_path: str, theme: str) -> dict:
@@ -66,7 +66,7 @@ def generate_updated_project(data: TOMLDocument, packages: List[dict]) -> Union[
     return None
 
 def to_packages(root: Path, namespace: str, diff: dict) -> List[dict]:
-    theme = workspace.parser.get_theme_from_config(root)
+    theme = configuration.get_theme_from_config(root)
     is_project = diff['is_project']
     bases_path = '../../bases' if is_project else 'bases'
     components_path = '../../components' if is_project else 'components'

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/polylith_cli/polylith/test/tests.py

@@ -1,17 +1,17 @@
 from pathlib import Path
 from polylith_cli.polylith.dirs import create_dir
 from polylith_cli.polylith.files import create_file
-from polylith_cli.polylith.workspace import parser
+from polylith_cli.polylith import configuration
 template = 'from {namespace}.{package} import {modulename}\n\n\ndef test_sample():\n    assert {modulename} is not None\n'
 
 def create_test(root: Path, options: dict) -> None:
-    if not parser.is_test_generation_enabled(root):
+    if not configuration.is_test_generation_enabled(root):
         return
     brick = options['brick']
     namespace = options['namespace']
     package = options['package']
     modulename = options['modulename']
-    dirs_structure = parser.get_tests_structure_from_config(root)
+    dirs_structure = configuration.get_tests_structure_from_config(root)
     dirs = dirs_structure.format(brick=brick, namespace=namespace, package=package)
     d = create_dir(root, dirs)
     create_file(d, '__init__.py')

polylith_cli-1.3.0/polylith_cli/polylith/workspace/__init__.py

@@ -0,0 +1,2 @@
+from polylith_cli.polylith.workspace import create, paths
+__all__ = ['create', 'paths']

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/polylith_cli/polylith/workspace/paths.py

@@ -1,7 +1,6 @@
 from pathlib import Path
 from typing import Set
-from polylith_cli.polylith import repo
-from polylith_cli.polylith.workspace import parser
+from polylith_cli.polylith import configuration, repo
 
 def get_path(structure: str, brick: str, ns: str, package: str) -> str:
     return structure.format(brick=brick, namespace=ns, package=package)
@@ -10,7 +9,7 @@ def get_paths(structure: str, brick: str, ns: str, packages: Set[str]) -> Set[st
     return {get_path(structure, brick, ns, p) for p in packages}
 
 def collect_paths(root: Path, ns: str, brick: str, packages: Set[str]) -> Set[Path]:
-    structure = parser.get_brick_structure_from_config(root)
+    structure = configuration.get_brick_structure_from_config(root)
     paths = get_paths(structure, brick, ns, packages)
     return {Path(root / p) for p in paths}
 

{polylith_cli-1.2.0 → polylith_cli-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "polylith-cli"
-version = "1.2.0"
+version = "1.3.0"
 description = "Python tooling support for the Polylith Architecture"
 authors = ['David Vujic']
 homepage = "https://davidvujic.github.io/python-polylith-docs/"

polylith_cli-1.2.0/polylith_cli/polylith/commands/__init__.py

@@ -1,2 +0,0 @@
-from polylith_cli.polylith.commands import check, create, diff, info, libs, sync
-__all__ = ['check', 'create', 'diff', 'info', 'libs', 'sync']

polylith_cli-1.2.0/polylith_cli/polylith/sync/collect.py

@@ -1,27 +0,0 @@
-from pathlib import Path
-from polylith_cli.polylith import check, info, workspace
-
-def get_brick_imports(root: Path, ns: str, project_data: dict) -> dict:
-    bases = {b for b in project_data.get('bases', [])}
-    components = {c for c in project_data.get('components', [])}
-    bases_paths = workspace.paths.collect_bases_paths(root, ns, bases)
-    components_paths = workspace.paths.collect_components_paths(root, ns, components)
-    brick_imports_in_bases = check.collect.extract_bricks(bases_paths, ns)
-    brick_imports_in_components = check.collect.extract_bricks(components_paths, ns)
-    return {'bases': check.collect.with_unknown_components(root, ns, brick_imports_in_bases), 'components': check.collect.with_unknown_components(root, ns, brick_imports_in_components)}
-
-def calculate_diff(root: Path, namespace: str, project_data: dict, workspace_data: dict) -> dict:
-    brick_imports = get_brick_imports(root, namespace, project_data)
-    all_bases = workspace_data['bases']
-    all_components = workspace_data['components']
-    bases = project_data['bases']
-    components = project_data['components']
-    is_project = info.is_project(project_data)
-    if is_project:
-        brick_diff = check.collect.imports_diff(brick_imports, bases, components)
-    else:
-        all_bricks = set().union(all_bases, all_components)
-        brick_diff = check.collect.diff(all_bricks, bases, components)
-    bases_diff = {b for b in brick_diff if b in all_bases}
-    components_diff = {b for b in brick_diff if b in all_components}
-    return {'name': project_data['name'], 'path': project_data['path'], 'is_project': is_project, 'bases': bases_diff, 'components': components_diff, 'brick_imports': brick_imports}

polylith_cli-1.2.0/polylith_cli/polylith/workspace/__init__.py

@@ -1,2 +0,0 @@
-from polylith_cli.polylith.workspace import create, parser, paths
-__all__ = ['create', 'parser', 'paths']