tree2project 0.1.0__py3-none-any.whl

tree2project/__init__.py

@@ -0,0 +1,3 @@
+from .version import version
+
+all = ["**version**"]

tree2project/cli.py

@@ -0,0 +1,89 @@
+import argparse
+
+from tree2project.commands.create import (
+    run as create_run
+)
+from tree2project.commands.export import (
+    run as export_run
+)
+from tree2project.commands.validate import (
+    run as validate_run
+)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="tree2project"
+    )
+
+    subparsers = parser.add_subparsers(
+        dest="command"
+    )
+
+    create_parser = subparsers.add_parser(
+        "create",
+        help="Create structure"
+    )
+
+    create_parser.add_argument(
+        "structure_file"
+    )
+
+    create_parser.add_argument(
+        "--target"
+    )
+
+    create_parser.add_argument(
+        "--dry-run",
+        action="store_true"
+    )
+
+    export_parser = subparsers.add_parser(
+        "export",
+        help="Export structure"
+    )
+
+    export_parser.add_argument(
+        "directory"
+    )
+
+    export_parser.add_argument(
+        "--output"
+    )
+
+    validate_parser = subparsers.add_parser(
+        "validate",
+        help="Validate structure"
+    )
+
+    validate_parser.add_argument(
+        "structure_file"
+    )
+
+    validate_parser.add_argument(
+        "--target",
+        required=True
+    )
+
+    args = parser.parse_args()
+
+    if args.command == "create":
+        raise SystemExit(
+            create_run(args)
+        )
+
+    elif args.command == "export":
+        raise SystemExit(
+            export_run(args)
+        )
+
+    elif args.command == "validate":
+        raise SystemExit(
+            validate_run(args)
+        )
+
+    parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

tree2project/commands/create.py

@@ -0,0 +1,89 @@
+from pathlib import Path
+
+from rich.console import Console
+from rich.table import Table
+
+from tree2project.parser import parse_structure
+from tree2project.creator import create_structure
+
+console = Console()
+
+
+def run(args):
+    structure_file = Path(args.structure_file)
+
+    if not structure_file.exists():
+        console.print(
+            f"[red]File not found:[/red] {structure_file}"
+        )
+        return 1
+
+    with open(
+        structure_file,
+        "r",
+        encoding="utf-8"
+    ) as f:
+        lines = f.readlines()
+
+    paths = parse_structure(lines)
+
+    target = (
+        Path(args.target).expanduser().resolve()
+        if args.target
+        else Path(
+            console.input(
+                "Target directory: "
+            )
+        ).expanduser().resolve()
+    )
+
+    table = Table(title="Structure Preview")
+
+    table.add_column("Type")
+    table.add_column("Path")
+
+    for path, is_dir in paths:
+        table.add_row(
+            "DIR" if is_dir else "FILE",
+            str(target / path)
+        )
+
+    console.print(table)
+
+    if args.dry_run:
+        console.print(
+            "[yellow]Dry run complete.[/yellow]"
+        )
+        return 0
+
+    confirm = console.input(
+        "Create structure? [y/N]: "
+    )
+
+    if confirm.lower() != "y":
+        console.print(
+            "[yellow]Cancelled[/yellow]"
+        )
+        return 0
+
+    result = create_structure(
+        paths,
+        target
+    )
+
+    console.print(
+        f"[green]Directories:[/green] "
+        f"{len(result['created_dirs'])}"
+    )
+
+    console.print(
+        f"[green]Files:[/green] "
+        f"{len(result['created_files'])}"
+    )
+
+    console.print(
+        f"[yellow]Skipped:[/yellow] "
+        f"{len(result['skipped_files'])}"
+    )
+
+    return 0

tree2project/commands/export.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+
+from rich.console import Console
+
+from tree2project.exporter import export_structure
+
+console = Console()
+
+
+def run(args):
+    root = Path(args.directory)
+
+    if not root.exists():
+        console.print(
+            f"[red]Directory not found:[/red] {root}"
+        )
+        return 1
+
+    structure = export_structure(root)
+
+    if args.output:
+        with open(
+            args.output,
+            "w",
+            encoding="utf-8"
+        ) as f:
+            f.write(structure)
+
+        console.print(
+            f"[green]Saved:[/green] {args.output}"
+        )
+    else:
+        console.print(structure)
+
+    return 0

tree2project/commands/validate.py

@@ -0,0 +1,43 @@
+from pathlib import Path
+
+from rich.console import Console
+
+from tree2project.parser import parse_structure
+from tree2project.validator import (
+    validate_structure
+)
+
+console = Console()
+
+
+def run(args):
+    structure_file = Path(args.structure_file)
+
+    with open(
+        structure_file,
+        "r",
+        encoding="utf-8"
+    ) as f:
+        lines = f.readlines()
+
+    paths = parse_structure(lines)
+
+    result = validate_structure(
+        paths,
+        args.target
+    )
+
+    if result["valid"]:
+        console.print(
+            "[green]Structure valid[/green]"
+        )
+        return 0
+
+    console.print(
+        "[red]Missing paths:[/red]"
+    )
+
+    for item in result["missing"]:
+        console.print(item)
+
+    return 1

tree2project/creator.py

@@ -0,0 +1,41 @@
+from pathlib import Path
+
+def create_structure(paths, target_dir, dry_run=False):
+    target_dir = Path(target_dir)
+
+
+    created_dirs = []
+    created_files = []
+    skipped_files = []
+
+    for relative_path, is_dir in paths:
+        full_path = target_dir / relative_path
+
+        if dry_run:
+            continue
+
+        if is_dir:
+            full_path.mkdir(
+                parents=True,
+                exist_ok=True
+            )
+            created_dirs.append(str(full_path))
+        else:
+            full_path.parent.mkdir(
+                parents=True,
+                exist_ok=True
+            )
+
+            if full_path.exists():
+                skipped_files.append(str(full_path))
+                continue
+
+            full_path.touch()
+            created_files.append(str(full_path))
+
+    return {
+        "created_dirs": created_dirs,
+        "created_files": created_files,
+        "skipped_files": skipped_files,
+    }
+    

tree2project/exporter.py

@@ -0,0 +1,42 @@
+
+from pathlib import Path
+
+
+def export_structure(root_path):
+    root = Path(root_path)
+
+    if not root.exists():
+        raise FileNotFoundError(root)
+
+    lines = [f"{root.name}/"]
+
+    def walk(directory, prefix=""):
+        items = sorted(
+            directory.iterdir(),
+            key=lambda p: (p.is_file(), p.name.lower())
+        )
+
+        for idx, item in enumerate(items):
+            last = idx == len(items) - 1
+
+            connector = "└── " if last else "├── "
+
+            if item.is_dir():
+                lines.append(
+                    f"{prefix}{connector}{item.name}/"
+                )
+
+                extension = "    " if last else "│   "
+
+                walk(
+                    item,
+                    prefix + extension
+                )
+            else:
+                lines.append(
+                    f"{prefix}{connector}{item.name}"
+                )
+
+    walk(root)
+
+    return "\n".join(lines)

tree2project/parser.py

@@ -0,0 +1,64 @@
+from pathlib import Path
+import re
+
+def parse_structure(lines):
+    paths = []
+    stack = []
+
+
+    for raw in lines:
+        line = raw.rstrip("\n")
+
+        if not line.strip():
+            continue
+
+        stripped = line.strip()
+
+        if re.fullmatch(r"[│\s]+", stripped):
+            continue
+
+        if not any(token in line for token in ("├──", "└──")):
+            name = stripped.rstrip("/")
+
+            if stripped.endswith("/"):
+                stack = [name]
+                paths.append((Path(name), True))
+            else:
+                paths.append((Path(name), False))
+
+            continue
+
+        prefix = (
+            line.split("├──")[0]
+            if "├──" in line
+            else line.split("└──")[0]
+        )
+
+        depth = len(prefix) // 4
+
+        name = re.sub(
+            r"^[ │]*(├──|└──)\s*",
+            "",
+            line,
+        ).strip()
+
+        is_dir = name.endswith("/")
+        name = name.rstrip("/")
+
+        while len(stack) > depth + 1:
+            stack.pop()
+
+        parent = Path(*stack) if stack else Path()
+        current = parent / name
+
+        paths.append((current, is_dir))
+
+        if is_dir:
+            if len(stack) == depth + 1:
+                stack.append(name)
+            else:
+                stack = stack[: depth + 1]
+                stack.append(name)
+
+    return paths
+

tree2project/validator.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+
+
+def validate_structure(paths, target_dir):
+    target_dir = Path(target_dir)
+
+    missing = []
+
+    for relative_path, is_dir in paths:
+        full_path = target_dir / relative_path
+
+        if not full_path.exists():
+            missing.append(str(full_path))
+            continue
+
+        if is_dir and not full_path.is_dir():
+            missing.append(str(full_path))
+
+        if not is_dir and not full_path.is_file():
+            missing.append(str(full_path))
+
+    return {
+        "valid": len(missing) == 0,
+        "missing": missing,
+    }

tree2project/version.py

@@ -0,0 +1 @@
+version = "0.1.0"

tree2project-0.1.0.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: tree2project
+Version: 0.1.0
+Summary: Create project folder structures from tree-format files
+Author-email: Dinesh kumar ummaneni <dineshkumarummaneni@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yourname/tree2project
+Project-URL: Repository, https://github.com/yourname/tree2project
+Keywords: cli,filesystem,project-generator,scaffold,tree
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.7.0
+Dynamic: license-file

tree2project-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+tree2project/__init__.py,sha256=WHi6FocJKDao1jtIW45ZRSEDjnV8DYKGT-gDDksMLqs,52
+tree2project/cli.py,sha256=8evTlExsDctOvFI2xb8Xeu8VF7mENpSb2hCDvY4FwPY,1561
+tree2project/creator.py,sha256=CVCzLHKviY-mSSnU2R0EwuIiP_ZA53LWHUrVtzuZceE,948
+tree2project/exporter.py,sha256=C6GutxW9wdbhnW8Zvie6T8IoIC8aWN7_MXtoPEhub18,956
+tree2project/parser.py,sha256=QMCXSb75iMkx9nrnFOdeFUzmyOlGtt1xtiRzT6XEAcM,1404
+tree2project/validator.py,sha256=7ZaK5Vwn9CQQ_doQQQLleTo9kfL4v0skRqOQkL6HzFM,579
+tree2project/version.py,sha256=aOHawL1zuHMfBWKXqwUkXcW96oXLNCY-CXdHDqkz4g4,18
+tree2project/commands/create.py,sha256=OzupKEGSxMMvMiIVbkOFLwObmoUDINVa9YlGwQJwFKI,1779
+tree2project/commands/export.py,sha256=d1AAqTM9fGzTUXrUv_KGbN5gCrX7aQQsSqGxySFiWEw,651
+tree2project/commands/validate.py,sha256=6E7wGiVaWDyuXwd_g_ODql39ntHxHam53biXghCSchY,745
+tree2project-0.1.0.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tree2project-0.1.0.dist-info/METADATA,sha256=Q14sNOSzv221WpYOnkTVqhzHy8KCCx00w0SqxNAq4hE,948
+tree2project-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+tree2project-0.1.0.dist-info/entry_points.txt,sha256=GNc6K6jDygrD1IDN2-67ua11P5BCRqnPLrQHHE7c7uI,55
+tree2project-0.1.0.dist-info/top_level.txt,sha256=suqoBy3dNCYhGMBrgUmtazE2ztGTP515g1dy7h3Ebpc,13
+tree2project-0.1.0.dist-info/RECORD,,

tree2project-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tree2project-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tree2project = tree2project.cli:main

tree2project-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+tree2project