polylith-cli 0.1.0__tar.gz

polylith_cli-0.1.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.1
+Name: polylith-cli
+Version: 0.1.0
+Summary: Python tooling support for the Polylith Architecture
+Home-page: https://davidvujic.github.io/python-polylith-docs/
+License: MIT
+Author: David Vujic
+Requires-Python: >=3.8,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: rich (>=13.6.0,<14.0.0)
+Requires-Dist: tomlkit (>=0.11.5,<0.12.0)
+Requires-Dist: typer[all] (>=0.9.0,<0.10.0)
+Project-URL: Repository, https://github.com/davidvujic/python-polylith
+Description-Content-Type: text/markdown
+
+# Python tooling for Polylith
+
+A command line interface that adds tooling support for the Polylith Architecture in Python.
+
+## Documentation
+Have a look at the [documentation](https://davidvujic.github.io/python-polylith-docs/).
+You will find installation, setup, usage guides and more.
+
+## Quick start
+
+`Poetry` user? For Poetry, the recommended setup is to install the `poetry-polylith-plugin`.
+Read more about Poetry in the [documentation](https://davidvujic.github.io/python-polylith-docs/installation/).
+
+### Setup: Hatch
+Create a directory for your code, initialize it with __git__ and setup the basics with `hatch`:
+
+``` shell
+git init
+
+hatch new --init
+```
+
+Add the Polylith CLI as a dev dependency in `pyproject.toml`:
+
+``` toml
+[tool.hatch.envs.default]
+dependencies = ["polylith-cli"]
+```
+
+Add configuration for a local virtual environment in the `pyproject.toml`:
+``` toml
+[tool.hatch.envs.default]
+type = "virtual"
+path = ".venv"
+python = "3.12"  # your preferred version here
+```
+
+Make `Hatch` aware of the Polylith structure, by adding this to the `pyproject.toml`:
+``` toml
+[tool.hatch.build]
+dev-mode-dirs = ["components", "bases", "development", "."]
+
+```
+
+Next: create a Polylith workspace, with a basic Polylith folder structure.
+The `poly` command is now available in the local virtual environment.
+You can run commands in the context of `hatch run` to make Polylith aware of the development environment.
+
+``` shell
+hatch run poly create workspace --name my_namespace --theme loose
+```
+
+### Ready for coding!
+
+Add components, bases and projects:
+
+``` shell
+hatch run poly create component --name my_component
+
+hatch run poly create base --name my_example_endpoint
+
+hatch run poly create project --name my_example_project
+```
+
+For details, have a look at the [documentation](https://davidvujic.github.io/python-polylith-docs/).
+There, you will find guides for setup, migration, packaging, available commands, code examples and more.
+

polylith_cli-0.1.0/README.md

@@ -0,0 +1,66 @@
+# Python tooling for Polylith
+
+A command line interface that adds tooling support for the Polylith Architecture in Python.
+
+## Documentation
+Have a look at the [documentation](https://davidvujic.github.io/python-polylith-docs/).
+You will find installation, setup, usage guides and more.
+
+## Quick start
+
+`Poetry` user? For Poetry, the recommended setup is to install the `poetry-polylith-plugin`.
+Read more about Poetry in the [documentation](https://davidvujic.github.io/python-polylith-docs/installation/).
+
+### Setup: Hatch
+Create a directory for your code, initialize it with __git__ and setup the basics with `hatch`:
+
+``` shell
+git init
+
+hatch new --init
+```
+
+Add the Polylith CLI as a dev dependency in `pyproject.toml`:
+
+``` toml
+[tool.hatch.envs.default]
+dependencies = ["polylith-cli"]
+```
+
+Add configuration for a local virtual environment in the `pyproject.toml`:
+``` toml
+[tool.hatch.envs.default]
+type = "virtual"
+path = ".venv"
+python = "3.12"  # your preferred version here
+```
+
+Make `Hatch` aware of the Polylith structure, by adding this to the `pyproject.toml`:
+``` toml
+[tool.hatch.build]
+dev-mode-dirs = ["components", "bases", "development", "."]
+
+```
+
+Next: create a Polylith workspace, with a basic Polylith folder structure.
+The `poly` command is now available in the local virtual environment.
+You can run commands in the context of `hatch run` to make Polylith aware of the development environment.
+
+``` shell
+hatch run poly create workspace --name my_namespace --theme loose
+```
+
+### Ready for coding!
+
+Add components, bases and projects:
+
+``` shell
+hatch run poly create component --name my_component
+
+hatch run poly create base --name my_example_endpoint
+
+hatch run poly create project --name my_example_project
+```
+
+For details, have a look at the [documentation](https://davidvujic.github.io/python-polylith-docs/).
+There, you will find guides for setup, migration, packaging, available commands, code examples and more.

polylith_cli-0.1.0/polylith_cli/polylith/alias/__init__.py

@@ -0,0 +1,2 @@
+from polylith_cli.polylith.alias.core import parse, pick
+__all__ = ['parse', 'pick']

polylith_cli-0.1.0/polylith_cli/polylith/alias/core.py

@@ -0,0 +1,23 @@
+from functools import reduce
+from typing import Dict, List, Set
+
+
+def _to_key_with_values(acc: Dict, alias: str) -> Dict:
+    k, v = str.split(alias, "=")
+
+    values = [str.strip(val) for val in str.split(v, ",")]
+
+    return {**acc, **{k: values}}
+
+
+def parse(aliases: List[str]) -> Dict[str, List[str]]:
+    """Parse a list of aliases defined as key=value(s) into a dictionary"""
+    return reduce(_to_key_with_values, aliases, {})
+
+
+def pick(aliases: Dict[str, List[str]], keys: Set) -> Set:
+    matrix = [v for k, v in aliases.items() if k in keys]
+
+    flattened: List = sum(matrix, [])
+
+    return set(flattened)

polylith_cli-0.1.0/polylith_cli/polylith/bricks/__init__.py

@@ -0,0 +1,3 @@
+from polylith_cli.polylith.bricks.base import create_base, get_bases_data
+from polylith_cli.polylith.bricks.component import create_component, get_components_data
+__all__ = ['create_base', 'create_component', 'get_bases_data', 'get_components_data']

polylith_cli-0.1.0/polylith_cli/polylith/bricks/base.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+from typing import List
+from polylith_cli.polylith.bricks import component
+from polylith_cli.polylith.bricks.brick import create_brick
+from polylith_cli.polylith.repo import bases_dir
+from polylith_cli.polylith.test import create_test
+
+def create_base(path: Path, options: dict) -> None:
+    extra = {'brick': bases_dir}
+    base_options = {**options, **extra}
+    create_brick(path, base_options)
+    create_test(path, base_options)
+
+def get_bases_data(path: Path, ns: str) -> List[dict]:
+    return component.get_components_data(path, ns, bases_dir)

polylith_cli-0.1.0/polylith_cli/polylith/bricks/brick.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+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_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):
+        create_brick_readme(root / resources_path, options)

polylith_cli-0.1.0/polylith_cli/polylith/bricks/component.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+from typing import List
+from polylith_cli.polylith import workspace
+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
+
+def create_component(path: Path, options: dict) -> None:
+    extra = {'brick': components_dir}
+    component_options = {**options, **extra}
+    create_brick(path, component_options)
+    create_test(path, component_options)
+
+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)
+    dirs = top_dir if theme == 'tdd' else f'{top_dir}/{ns}'
+    component_dir = root / dirs
+    if not component_dir.exists():
+        return []
+    return [f for f in component_dir.iterdir() if is_brick_dir(f)]
+
+def get_components_data(root: Path, ns: str, top_dir: str=components_dir) -> List[dict]:
+    dirs = get_component_dirs(root, top_dir, ns)
+    return [{'name': d.name} for d in dirs]

polylith_cli-0.1.0/polylith_cli/polylith/check/__init__.py

@@ -0,0 +1,2 @@
+from polylith_cli.polylith.check import collect, grouping, report
+__all__ = ['collect', 'grouping', 'report']

polylith_cli-0.1.0/polylith_cli/polylith/check/collect.py

@@ -0,0 +1,30 @@
+from pathlib import Path
+from typing import List, Set
+from polylith_cli.polylith import check, imports, workspace
+
+def extract_bricks(paths: Set[Path], ns: str) -> dict:
+    all_imports = imports.fetch_all_imports(paths)
+    return check.grouping.extract_brick_imports(all_imports, ns)
+
+def with_unknown_components(root: Path, ns: str, brick_imports: dict) -> dict:
+    keys = set(brick_imports.keys())
+    values = set().union(*brick_imports.values())
+    unknowns = values.difference(keys)
+    if not unknowns:
+        return brick_imports
+    paths = workspace.paths.collect_components_paths(root, ns, unknowns)
+    extracted = extract_bricks(paths, ns)
+    if not extracted:
+        return brick_imports
+    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]:
+    bricks = set().union(bases, components)
+    return known_bricks.difference(bricks)
+
+def imports_diff(brick_imports: dict, bases: List, components: List) -> 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)
+    return diff(flattened_imports, bases, components)

polylith_cli-0.1.0/polylith_cli/polylith/check/grouping.py

@@ -0,0 +1,36 @@
+from typing import Set, Union
+
+
+def only_brick_imports(imports: Set[str], top_ns: str) -> Set[str]:
+    return {i for i in imports if i.startswith(top_ns)}
+
+
+def only_bricks(import_data: dict, top_ns: str) -> dict:
+    return {k: only_brick_imports(v, top_ns) for k, v in import_data.items()}
+
+
+def brick_import_to_name(brick_import: str) -> Union[str, None]:
+    parts = brick_import.split(".")
+
+    return parts[1] if len(parts) > 1 else None
+
+
+def only_brick_name(brick_imports: Set[str]) -> Set:
+    res = {brick_import_to_name(i) for i in brick_imports}
+
+    return {i for i in res if i}
+
+
+def only_brick_names(import_data: dict) -> dict:
+    return {k: only_brick_name(v) for k, v in import_data.items() if v}
+
+
+def exclude_empty(import_data: dict) -> dict:
+    return {k: v for k, v in import_data.items() if v}
+
+
+def extract_brick_imports(all_imports: dict, top_ns) -> dict:
+    with_only_bricks = only_bricks(all_imports, top_ns)
+    with_only_brick_names = only_brick_names(with_only_bricks)
+
+    return exclude_empty(with_only_brick_names)

polylith_cli-0.1.0/polylith_cli/polylith/check/report.py

@@ -0,0 +1,47 @@
+from pathlib import Path
+from typing import Set
+from polylith_cli.polylith import imports, libs, workspace
+from polylith_cli.polylith.check import collect, grouping
+from polylith_cli.polylith.reporting import theme
+from rich.console import Console
+
+def print_brick_imports(brick_imports: dict) -> None:
+    console = Console(theme=theme.poly_theme)
+    bases = brick_imports['bases']
+    components = brick_imports['components']
+    bricks = {**bases, **components}
+    for key, values in bricks.items():
+        imports_in_brick = values.difference({key})
+        if imports_in_brick:
+            console.print(f':information: [data]{key}[/] is importing [data]{', '.join(imports_in_brick)}[/]')
+
+def print_missing_deps(diff: Set[str], project_name: str) -> None:
+    if not diff:
+        return
+    console = Console(theme=theme.poly_theme)
+    missing = ', '.join(sorted(diff))
+    console.print(f':thinking_face: Cannot locate {missing} in {project_name}')
+
+def fetch_brick_imports(root: Path, ns: str, all_imports: dict) -> dict:
+    extracted = grouping.extract_brick_imports(all_imports, ns)
+    return collect.with_unknown_components(root, ns, extracted)
+
+def collect_all_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)
+    all_imports_in_bases = imports.fetch_all_imports(bases_paths)
+    all_imports_in_components = imports.fetch_all_imports(components_paths)
+    brick_imports = {'bases': fetch_brick_imports(root, ns, all_imports_in_bases), 'components': fetch_brick_imports(root, ns, all_imports_in_components)}
+    third_party_imports = {'bases': libs.extract_third_party_imports(all_imports_in_bases, ns), 'components': libs.extract_third_party_imports(all_imports_in_components, ns)}
+    return {'brick_imports': brick_imports, 'third_party_imports': third_party_imports}
+
+def create_report(project_data: dict, collected_imports: dict, third_party_libs: Set, is_strict: bool=False) -> dict:
+    bases = {b for b in project_data.get('bases', [])}
+    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))
+    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-0.1.0/polylith_cli/polylith/cli/__init__.py

@@ -0,0 +1,2 @@
+from polylith_cli.polylith.cli import core
+__all__ = ['core']

polylith_cli-0.1.0/polylith_cli/polylith/cli/__main__.py

@@ -0,0 +1,2 @@
+from polylith_cli.polylith.cli.core import app
+app(prog_name='poly')

polylith_cli-0.1.0/polylith_cli/polylith/cli/core.py

@@ -0,0 +1,58 @@
+from pathlib import Path
+from polylith_cli.polylith import commands, info, repo, workspace
+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.')
+
+@app.command('info')
+def info_command(short: Annotated[bool, options.short_workspace]=False):
+    """Info about the Polylith workspace."""
+    commands.info.run(short)
+
+@app.command('check')
+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)
+    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()]
+    results = {commands.check.run(root, ns, p, cli_options) for p in projects_data}
+    if not all(results):
+        raise Exit(code=1)
+
+@app.command('diff')
+def diff_command(since: Annotated[str, Option(help='Changed since a specific tag.')]='', short: Annotated[bool, options.short]=False, bricks: Annotated[bool, Option(help='Print changed bricks.')]=False):
+    """Shows changed bricks compared to the latest git tag."""
+    commands.diff.run(since, short, bricks)
+
+@app.command('libs')
+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)
+    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()]
+    results = {commands.libs.run(root, ns, p, cli_options) for p in projects_data}
+    if not all(results):
+        raise Exit(code=1)
+
+@app.command('sync')
+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)
+    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()]
+    for p in projects_data:
+        commands.sync.run(root, ns, p, cli_options)
+if __name__ == '__main__':
+    app()

polylith_cli-0.1.0/polylith_cli/polylith/cli/create.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+from typing import Union
+from polylith_cli.polylith import project, repo
+from polylith_cli.polylith.bricks import base, component
+from polylith_cli.polylith.commands.create import create
+from polylith_cli.polylith.workspace.create import create_workspace
+from typer import Exit, Option, Typer
+from typing_extensions import Annotated
+app = Typer()
+
+@app.command('base')
+def base_command(name: Annotated[str, Option(help='Name of the base.')], description: Annotated[str, Option(help='Description of the base.')]=''):
+    """Creates a Polylith base."""
+    create(name, description, base.create_base)
+
+@app.command('component')
+def component_command(name: Annotated[str, Option(help='Name of the component.')], description: Annotated[str, Option(help='Description of the component.')]=''):
+    """Creates a Polylith component."""
+    create(name, description, component.create_component)
+
+def _create_project(root: Path, _ns: str, name: str, description: Union[str, None]):
+    root_pyproject: dict = project.get_toml(root / repo.default_toml)
+    if repo.is_poetry(root_pyproject):
+        template = project.templates.poetry_pyproject
+    elif repo.is_hatch(root_pyproject):
+        template = project.templates.hatch_pyproject
+    if not template:
+        print('Failed to guess the used Package & Dependency Management')
+        print('Is the root pyproject.toml missing, or are you using a tool not supported by Polylith?')
+        raise Exit(code=1)
+    project.create_project(root, template, name, description or '')
+
+@app.command('project')
+def project_command(name: Annotated[str, Option(help='Name of the project.')], description: Annotated[str, Option(help='Description of the project.')]=''):
+    """Creates a Polylith project."""
+    create(name, description, _create_project)
+
+@app.command('workspace')
+def workspace_command(name: Annotated[str, Option(help='Name of the workspace.')], theme: Annotated[str, Option(help='Workspace theme.')]='tdd'):
+    """Creates a Polylith workspace in the current directory."""
+    path = Path.cwd()
+    create_workspace(path, name, theme)

polylith_cli-0.1.0/polylith_cli/polylith/cli/options.py

@@ -0,0 +1,17 @@
+from typer import Option
+
+alias = Option(
+    help="alias for third-party libraries, useful when an import differ from the library name"
+)
+directory = Option(
+    help="The working directory for the command (defaults to the current working directory)."
+)
+
+short = Option(help="Print short view.")
+short_workspace = Option(help="Display Workspace Info adjusted for many projects.")
+strict = Option(
+    help="More strict checks when matching name of third-party libraries and imports"
+)
+
+verbose = Option(help="More verbose output.")
+quiet = Option(help="Do not output any messages.")

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

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

polylith_cli-0.1.0/polylith_cli/polylith/commands/check.py

@@ -0,0 +1,26 @@
+import importlib.metadata
+from pathlib import Path
+from polylith_cli.polylith import alias, check, distributions
+
+def run(root: Path, ns: str, project_data: dict, options: dict) -> bool:
+    is_verbose = options['verbose']
+    is_quiet = options['quiet']
+    is_strict = options['strict']
+    library_alias = options['alias']
+    third_party_libs = project_data['deps']
+    name = project_data['name']
+    collected_imports = check.report.collect_all_imports(root, ns, project_data)
+    dists = importlib.metadata.distributions()
+    known_aliases = distributions.distributions_packages(dists)
+    known_aliases.update(alias.parse(library_alias))
+    extra = alias.pick(known_aliases, third_party_libs)
+    libs = third_party_libs.union(extra)
+    details = check.report.create_report(project_data, collected_imports, libs, is_strict)
+    res = all([not details['brick_diff'], not details['libs_diff']])
+    if not is_quiet:
+        check.report.print_missing_deps(details['brick_diff'], name)
+        check.report.print_missing_deps(details['libs_diff'], name)
+        if is_verbose:
+            check.report.print_brick_imports(details['brick_imports'])
+            check.report.print_brick_imports(details['third_party_imports'])
+    return res

polylith_cli-0.1.0/polylith_cli/polylith/commands/create.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+from typing import Union
+from polylith_cli.polylith import repo, workspace
+
+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)
+    if not name:
+        raise ValueError('Please add a name by using --name')
+    if not namespace:
+        raise ValueError("Didn't find a namespace. Expected to find it in workspace.toml.")
+    options = {'namespace': namespace, 'package': name, 'description': description, 'modulename': 'core'}
+    fn(root, options)

polylith_cli-0.1.0/polylith_cli/polylith/commands/diff.py

@@ -0,0 +1,30 @@
+from pathlib import Path
+from typing import Union
+from polylith_cli.polylith import diff, info, repo, workspace
+
+def print_views(root: Path, tag: str, short: bool, only_bricks: bool) -> None:
+    ns = workspace.parser.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)
+    projects = diff.collect.get_changed_projects(files)
+    all_projects_data = info.get_bricks_in_projects(root, components, bases, ns)
+    projects_data = [p for p in all_projects_data if info.is_project(p)]
+    affected_projects = diff.collect.get_projects_affected_by_changes(projects_data, projects, bases, components)
+    if not short and (not only_bricks):
+        diff.report.print_diff_summary(tag, bases, components)
+        diff.report.print_detected_changes_in_projects(projects, short)
+        diff.report.print_diff_details(projects_data, bases, components)
+        return
+    if short and (not only_bricks):
+        diff.report.print_projects_affected_by_changes(affected_projects, short)
+        return
+    diff.report.print_detected_changes_in_bricks(bases, components, short)
+
+def run(tag_name: Union[str, None], short: bool, only_bricks: bool):
+    root = repo.get_workspace_root(Path.cwd())
+    tag = diff.collect.get_latest_tag(root, tag_name)
+    if not tag:
+        print('No tags found in repository.')
+        return
+    print_views(root, tag, short, only_bricks)

polylith_cli-0.1.0/polylith_cli/polylith/commands/info.py

@@ -0,0 +1,16 @@
+from pathlib import Path
+from polylith_cli.polylith import info, repo, workspace
+
+def run(short: bool):
+    root = repo.get_workspace_root(Path.cwd())
+    ns = workspace.parser.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)
+    info.print_workspace_summary(projects_data, bases, components)
+    if not components and (not bases):
+        return
+    if short:
+        info.print_compressed_view_for_bricks_in_projects(projects_data, bases, components)
+    else:
+        info.print_bricks_in_projects(projects_data, bases, components)

polylith_cli-0.1.0/polylith_cli/polylith/commands/libs.py

@@ -0,0 +1,16 @@
+from pathlib import Path
+from polylith_cli.polylith import alias
+from polylith_cli.polylith.libs import report
+
+def run(root: Path, ns: str, project_data: dict, options: dict) -> bool:
+    is_strict = options['strict']
+    library_alias = options['alias']
+    name = project_data['name']
+    third_party_libs = project_data['deps']
+    brick_imports = report.get_third_party_imports(root, ns, project_data)
+    report.print_libs_summary(brick_imports, project_data)
+    report.print_libs_in_bricks(brick_imports)
+    library_aliases = alias.parse(library_alias)
+    extra = alias.pick(library_aliases, third_party_libs)
+    libs = third_party_libs.union(extra)
+    return report.print_missing_installed_libs(brick_imports, libs, name, is_strict)

polylith_cli-0.1.0/polylith_cli/polylith/commands/sync.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+from polylith_cli.polylith import info
+from polylith_cli.polylith import sync
+
+def run(root: Path, ns: str, project_data: dict, options: dict):
+    is_quiet = options['quiet']
+    is_verbose = options['verbose']
+    bases = info.get_bases(root, ns)
+    components = info.get_components(root, ns)
+    workspace_data = {'bases': bases, 'components': components}
+    diff = sync.calculate_diff(root, ns, project_data, workspace_data)
+    sync.update_project(root, ns, diff)
+    if is_quiet:
+        return
+    sync.report.print_summary(diff)
+    if is_verbose:
+        sync.report.print_brick_imports(diff)

polylith_cli-0.1.0/polylith_cli/polylith/development/__init__.py

@@ -0,0 +1,2 @@
+from polylith_cli.polylith.development.development import create_development
+__all__ = ['create_development']

polylith_cli-0.1.0/polylith_cli/polylith/development/development.py

@@ -0,0 +1,6 @@
+from pathlib import Path
+from polylith_cli.polylith.dirs import create_dir
+from polylith_cli.polylith.repo import development_dir
+
+def create_development(path: Path, keep=True) -> None:
+    create_dir(path, development_dir, keep=keep)

polylith_cli-0.1.0/polylith_cli/polylith/diff/__init__.py

@@ -0,0 +1,2 @@
+from polylith_cli.polylith.diff import collect, report
+__all__ = ['collect', 'report']