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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: polylith-cli
-Version: 1.2.1
+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.1 → 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.1 → 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.1 → polylith_cli-1.3.0}/polylith_cli/polylith/cli/core.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+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
@@ -6,6 +7,10 @@ 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."""
@@ -19,8 +24,7 @@ def check_command(strict: Annotated[bool, options.strict]=False, verbose: Annota
     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)
@@ -35,10 +39,9 @@ def libs_command(strict: Annotated[bool, options.strict]=False, directory: Annot
     """Show third-party libraries used in the workspace."""
     root = repo.get_workspace_root(Path.cwd())
     ns = configuration.get_namespace_from_config(root)
-    projects_data = info.get_projects_data(root, ns)
+    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)
@@ -48,11 +51,18 @@ def sync_command(strict: Annotated[bool, options.strict]=False, quiet: Annotated
     """Update pyproject.toml with missing bricks."""
     root = repo.get_workspace_root(Path.cwd())
     ns = configuration.get_namespace_from_config(root)
-    projects_data = info.get_projects_data(root, ns)
+    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.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.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.1 → 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.1 → 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.1 → 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.1 → polylith_cli-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "polylith-cli"
-version = "1.2.1"
+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.1/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.1/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}