tree2project 0.1.0__tar.gz

tree2project-0.1.0/PKG-INFO

@@ -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/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tree2project"
+version = "0.1.0"
+description = "Create project folder structures from tree-format files"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+
+authors = [
+{ name = "Dinesh kumar ummaneni", email = "dineshkumarummaneni@gmail.com" }
+]
+
+keywords = [
+"cli",
+"filesystem",
+"project-generator",
+"scaffold",
+"tree"
+]
+
+classifiers = [
+"Development Status :: 4 - Beta",
+"Environment :: Console",
+"Intended Audience :: Developers",
+"License :: OSI Approved :: MIT License",
+"Programming Language :: Python :: 3",
+"Programming Language :: Python :: 3.9",
+"Programming Language :: Python :: 3.10",
+"Programming Language :: Python :: 3.11",
+"Programming Language :: Python :: 3.12"
+]
+
+dependencies = [
+"rich>=13.7.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/yourname/tree2project"
+Repository = "https://github.com/yourname/tree2project"
+
+[project.scripts]
+tree2project = "tree2project.cli:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

tree2project-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tree2project-0.1.0/src/tree2project/__init__.py

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

tree2project-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/tree2project/version.py

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

tree2project-0.1.0/src/tree2project.egg-info/PKG-INFO

@@ -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/src/tree2project.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+README.md
+pyproject.toml
+src/tree2project/__init__.py
+src/tree2project/cli.py
+src/tree2project/creator.py
+src/tree2project/exporter.py
+src/tree2project/parser.py
+src/tree2project/validator.py
+src/tree2project/version.py
+src/tree2project.egg-info/PKG-INFO
+src/tree2project.egg-info/SOURCES.txt
+src/tree2project.egg-info/dependency_links.txt
+src/tree2project.egg-info/entry_points.txt
+src/tree2project.egg-info/requires.txt
+src/tree2project.egg-info/top_level.txt
+src/tree2project/commands/create.py
+src/tree2project/commands/export.py
+src/tree2project/commands/validate.py
+tests/test_exporter.py
+tests/test_parser.py

tree2project-0.1.0/src/tree2project.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tree2project-0.1.0/src/tree2project.egg-info/entry_points.txt

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

tree2project-0.1.0/src/tree2project.egg-info/requires.txt

@@ -0,0 +1 @@
+rich>=13.7.0

tree2project-0.1.0/src/tree2project.egg-info/top_level.txt

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

tree2project-0.1.0/tests/test_exporter.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+
+from tree2project.exporter import (
+    export_structure
+)
+
+
+def test_export(tmp_path):
+    root = tmp_path / "sample"
+
+    root.mkdir()
+
+    (root / "README.md").touch()
+
+    output = export_structure(root)
+
+    assert "README.md" in output

tree2project-0.1.0/tests/test_parser.py

@@ -0,0 +1,16 @@
+from tree2project.parser import (
+    parse_structure
+)
+
+
+def test_parse():
+    data = [
+        "project/\n",
+        "├── README.md\n",
+        "└── src/\n",
+        "    └── main.py\n",
+    ]
+
+    result = parse_structure(data)
+
+    assert len(result) == 4