gentem 0.1.3__py3-none-any.whl

gentem/template_engine.py

@@ -0,0 +1,191 @@
+"""Template engine for Gentem using Jinja2."""
+
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from jinja2 import (
+    BaseLoader,
+    Environment,
+    FileSystemLoader,
+    TemplateSyntaxError,
+    UndefinedError,
+)
+from rich import print
+from rich.panel import Panel
+from rich.tree import Tree
+
+
+class TemplateEngine:
+    """Jinja2 template engine for generating project files."""
+
+    def __init__(self, template_dir: Optional[str] = None) -> None:
+        """Initialize the template engine.
+
+        Args:
+            template_dir: Base directory for templates. If not provided,
+                         uses the gentem templates directory.
+        """
+        if template_dir:
+            self.template_dir = Path(template_dir)
+        else:
+            # Find the package directory
+            package_dir = Path(__file__).parent.parent
+            self.template_dir = package_dir / "templates"
+
+        self.env = Environment(
+            loader=FileSystemLoader(str(self.template_dir)),
+            autoescape=True,
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+    def get_template(self, template_path: str) -> "jinja2.Template":
+        """Get a template by path.
+
+        Args:
+            template_path: Path to the template relative to template_dir.
+
+        Returns:
+            The Jinja2 template.
+
+        Raises:
+            FileNotFoundError: If template not found.
+        """
+        try:
+            return self.env.get_template(template_path)
+        except TemplateSyntaxError as e:
+            raise TemplateSyntaxError(
+                f"Syntax error in template {template_path}: {e.message}",
+                lineno=e.lineno,
+            ) from e
+        except UndefinedError as e:
+            raise UndefinedError(
+                f"Undefined variable in template {template_path}: {e.message}"
+            ) from e
+
+    def render_template(
+        self,
+        template_path: str,
+        context: Dict[str, Any],
+    ) -> str:
+        """Render a template with the given context.
+
+        Args:
+            template_path: Path to the template relative to template_dir.
+            context: Variables to pass to the template.
+
+        Returns:
+            The rendered template content.
+        """
+        template = self.get_template(template_path)
+        return template.render(**context)
+
+    def render_file(
+        self,
+        template_path: str,
+        context: Dict[str, Any],
+        output_path: Path,
+    ) -> None:
+        """Render a template to a file.
+
+        Args:
+            template_path: Path to the template relative to template_dir.
+            context: Variables to pass to the template.
+            output_path: Path to write the rendered file.
+        """
+        content = self.render_template(template_path, context)
+
+        # Ensure parent directory exists
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Write the file
+        output_path.write_text(content, encoding="utf-8")
+
+    def list_templates(self, subdir: Optional[str] = None) -> list[str]:
+        """List all templates in a subdirectory.
+
+        Args:
+            subdir: Subdirectory within template_dir to list.
+
+        Returns:
+            List of template paths.
+        """
+        search_dir = self.template_dir
+        if subdir:
+            search_dir = search_dir / subdir
+
+        if not search_dir.exists():
+            return []
+
+        templates = []
+        for root, _, files in os.walk(search_dir):
+            for file in files:
+                if file.endswith((".j2", ".jinja2")):
+                    rel_path = Path(root).relative_to(self.template_dir)
+                    templates.append(str(rel_path / file))
+
+        return sorted(templates)
+
+    def preview_tree(
+        self,
+        template_paths: list[str],
+        context: Dict[str, Any],
+    ) -> Tree:
+        """Preview the file tree that would be generated.
+
+        Args:
+            template_paths: List of template paths to render.
+            context: Variables to pass to the templates.
+
+        Returns:
+            A Rich Tree showing the file structure.
+        """
+        tree = Tree("Project Structure", guide_style="bold.cyan")
+
+        for template_path in template_paths:
+            # Get the output path (remove .j2 extension)
+            output_path = template_path
+            if output_path.endswith((".j2", ".jinja2")):
+                output_path = output_path[:-3]  # Remove .j2
+
+            # Render the path with context
+            try:
+                rendered_path = self.render_template(
+                    f"_paths/{output_path}.path.j2", context
+                )
+            except Exception:
+                # Fallback to template path
+                rendered_path = output_path
+
+            # Add to tree
+            parts = Path(rendered_path).parts
+            current = tree
+            for i, part in enumerate(parts):
+                is_last = i == len(parts) - 1
+                if is_last:
+                    current.add(f"[cyan]{part}[/]")
+                else:
+                    # Find or create branch
+                    found = False
+                    for child in current.children:
+                        if child.label and str(child.label).strip("[]") == part:
+                            current = child
+                            found = True
+                            break
+                    if not found:
+                        current = current.add(f"[bold]{part}/[/]")
+
+        return tree
+
+
+# Global template engine instance
+_engine: Optional[TemplateEngine] = None
+
+
+def get_template_engine() -> TemplateEngine:
+    """Get the global template engine instance."""
+    global _engine
+    if _engine is None:
+        _engine = TemplateEngine()
+    return _engine

gentem/utils/__init__.py

@@ -0,0 +1,13 @@
+"""Utilities package for Gentem."""
+
+from gentem.utils.validators import (
+    validate_project_name,
+    validate_python_identifier,
+    validate_license_type,
+)
+
+__all__ = [
+    "validate_project_name",
+    "validate_python_identifier",
+    "validate_license_type",
+]

gentem/utils/validators.py

@@ -0,0 +1,158 @@
+"""Input validators for Gentem."""
+
+import re
+from pathlib import Path
+from typing import Optional
+
+
+class ValidationError(Exception):
+    """Raised when validation fails."""
+
+    pass
+
+
+def validate_python_identifier(name: str) -> bool:
+    """Check if the name is a valid Python identifier."""
+    pattern = r"^[a-zA-Z_][a-zA-Z0-9_]*$"
+    return bool(re.match(pattern, name))
+
+
+def validate_project_name(name: str) -> str:
+    """Validate and return the project name.
+
+    Args:
+        name: The project name to validate.
+
+    Returns:
+        The validated project name.
+
+    Raises:
+        ValidationError: If the name is invalid.
+    """
+    if not name:
+        raise ValidationError("Project name cannot be empty.")
+
+    if not validate_python_identifier(name):
+        raise ValidationError(
+            f"'{name}' is not a valid Python project name. "
+            "Use only letters, numbers, and underscores, starting with a letter or underscore."
+        )
+
+    # Check for Python reserved words
+    reserved_words = {
+        "and", "as", "assert", "async", "await", "break", "class", "continue",
+        "def", "del", "elif", "else", "except", "finally", "for", "from",
+        "global", "if", "import", "in", "is", "lambda", "nonlocal", "not",
+        "or", "pass", "raise", "return", "try", "while", "with", "yield", "True",
+        "False", "None",
+    }
+
+    if name.lower() in reserved_words:
+        raise ValidationError(
+            f"'{name}' is a Python reserved word and cannot be used as a project name."
+        )
+
+    return name
+
+
+def validate_license_type(license_type: str) -> str:
+    """Validate and normalize the license type.
+
+    Args:
+        license_type: The license type to validate.
+
+    Returns:
+        The normalized license type.
+
+    Raises:
+        ValidationError: If the license type is invalid.
+    """
+    valid_licenses = {"mit", "apache", "gpl", "bsd", "none", ""}
+
+    normalized = license_type.lower().strip()
+    if normalized not in valid_licenses:
+        raise ValidationError(
+            f"Invalid license type: '{license_type}'. "
+            f"Valid options are: {', '.join(sorted(valid_licenses))}"
+        )
+
+    return normalized
+
+
+def validate_project_type(project_type: str) -> str:
+    """Validate and normalize the project type.
+
+    Args:
+        project_type: The project type to validate.
+
+    Returns:
+        The normalized project type.
+
+    Raises:
+        ValidationError: If the project type is invalid.
+    """
+    valid_types = {"library", "cli", "script"}
+
+    normalized = project_type.lower().strip()
+    if normalized not in valid_types:
+        raise ValidationError(
+            f"Invalid project type: '{project_type}'. "
+            f"Valid options are: {', '.join(sorted(valid_types))}"
+        )
+
+    return normalized
+
+
+def validate_db_type(db_type: str) -> Optional[str]:
+    """Validate the database type.
+
+    Args:
+        db_type: The database type to validate.
+
+    Returns:
+        The normalized database type or None.
+
+    Raises:
+        ValidationError: If the database type is invalid.
+    """
+    if not db_type:
+        return None
+
+    valid_db_types = {"asyncpg", "sqlite", "postgres", "postgresql"}
+
+    normalized = db_type.lower().strip()
+    if normalized not in valid_db_types:
+        raise ValidationError(
+            f"Invalid database type: '{db_type}'. "
+            f"Valid options are: {', '.join(sorted(valid_db_types))} or empty for none."
+        )
+
+    # Normalize postgres/postgresql to asyncpg for now
+    if normalized in {"postgres", "postgresql"}:
+        normalized = "asyncpg"
+
+    return normalized
+
+
+def validate_output_path(path: str, dry_run: bool = False) -> Path:
+    """Validate the output path.
+
+    Args:
+        path: The path to validate.
+        dry_run: Whether this is a dry run.
+
+    Returns:
+        The validated Path object.
+
+    Raises:
+        ValidationError: If the path is invalid.
+    """
+    output_path = Path(path)
+
+    if output_path.exists() and not dry_run:
+        raise ValidationError(
+            f"Directory '{output_path}' already exists. "
+            "Please choose a different project name or remove the existing directory."
+        )
+
+    return output_path

gentem-0.1.3.dist-info/METADATA

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: gentem
+Version: 0.1.3
+Summary: A Python CLI template boilerplate generator
+Author-email: Abu Bakr <mabs2406@gmail.com>
+License: MIT
+Keywords: cli,boilerplate,template,generator,scaffolding
+Classifier: Development Status :: 3 - Alpha
+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: typer>=0.9.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.5.0; extra == "dev"
+Requires-Dist: types-pyyaml>=6.0.0; extra == "dev"
+Dynamic: license-file
+
+# Gentem
+
+![Python Version](https://img.shields.io/pypi/pyversions/gentem)
+![License](https://img.shields.io/pypi/l/gentem)
+![PyPI Version](https://img.shields.io/pypi/v/gentem)
+![PyPI Status](https://img.shields.io/pypi/status/gentem)
+
+![Downloads](https://img.shields.io/pypi/dm/gentem)
+![Last Commit](https://img.shields.io/github/last-commit/knightlesssword/gentem)
+![Contributors](https://img.shields.io/github/contributors/knightlesssword/gentem)
+
+
+A Python CLI template boilerplate generator for quickly scaffolding Python projects.
+
+## Features
+
+- **Project Scaffolding**: Generate Python projects with a single command
+- **Multiple Project Types**: Support for library, CLI tool, and script projects
+- **FastAPI Templates**: Pre-configured FastAPI project templates with optional database support
+- **Opinionated Structure**: Best practices baked into every template
+- **Interactive Preview**: `--dry-run` option to preview before creating files
+
+## Installation
+
+```bash
+pip install gentem
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/knightlesssword/gentem.git
+cd gentem
+pip install -e .
+```
+
+## Usage
+
+### Creating a New Project
+
+```bash
+# Create a library project
+gentem new mylib --type library
+
+# Create a CLI tool project
+gentem new mycli --type cli
+
+# Create a simple script project
+gentem new myscript --type script
+
+# With author and description
+gentem new mylib --type library --author "John Doe" --description "My library"
+
+# With license
+gentem new mylib --type library --license mit
+gentem new mylib --type library --license apache
+gentem new mylib --type library --license gpl
+
+# Preview without creating files
+gentem new mylib --type library --dry-run
+```
+
+### Creating a FastAPI Project
+
+```bash
+# Create a basic FastAPI project
+gentem fastapi myapi
+
+# Create with async mode and lifespan
+gentem fastapi myapi --async
+
+# Create with database support (asyncpg)
+gentem fastapi myapi --db asyncpg
+
+# Combine options
+gentem fastapi myapi --async --db asyncpg --author "John Doe"
+```
+
+## Project Structure
+
+### Library Template
+```
+mylib/
+├── src/
+│   └── mylib/
+│       ├── __init__.py
+│       └── core.py
+├── tests/
+│   ├── __init__.py
+│   └── test_core.py
+├── pyproject.toml
+├── README.md
+├── LICENSE
+└── .gitignore
+```
+
+### FastAPI Template
+```
+myapi/
+├── src/
+│   └── myapi/
+│       ├── __init__.py
+│       ├── main.py              # FastAPI application
+│       ├── core/
+│       │   ├── __init__.py
+│       │   ├── config.py        # Settings
+│       │   └── exceptions.py    # Custom exceptions
+│       ├── deps/
+│       │   └── __init__.py      # Dependencies
+│       ├── utils/
+│       │   └── __init__.py      # Utility functions
+│       ├── v1/
+│       │   ├── __init__.py
+│       │   └── apis/
+│       │       ├── __init__.py
+│       │       └── routes.py    # API routes
+│       ├── services/
+│       │   └── __init__.py      # Business logic
+│       ├── schemas/
+│       │   └── __init__.py      # Pydantic schemas
+│       └── models/
+│           └── __init__.py      # SQLAlchemy models
+├── .env
+├── requirements.txt
+├── .gitignore
+└── README.md
+```
+
+## Development
+
+```bash
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Format code
+black .
+ruff check --fix .
+
+# Type checking
+mypy .
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

gentem-0.1.3.dist-info/RECORD

@@ -0,0 +1,15 @@
+gentem/__init__.py,sha256=gW0VRbNnpFuyVzLPzO7A0vp0O0bs5oIV-cQx7RBX30E,86
+gentem/__main__.py,sha256=1j3yOSbbv3Yfrr9HMuQD2zes6SpiiqwIksPSFcntlps,114
+gentem/cli.py,sha256=tTgEUTS78nZBsZ0DyJb9vMLWu1Ow8L7KVetRRe8BCNU,4007
+gentem/template_engine.py,sha256=WWu5m1h63lD0pxVHUSftEnFFWNf1OYqHQ01pGvb9qq0,6019
+gentem/commands/__init__.py,sha256=_dNABeV14JFMeOB1htS-bzqj87EA99X1VSXw-37QIhM,36
+gentem/commands/fastapi.py,sha256=BUH4Y-KkOA56XJNO01zyFlfbMClNlNT9KOWE0vMiolI,20267
+gentem/commands/new.py,sha256=OYTTSBz9X6MObYKpIKPFhyzQJ3PyU1owcfxwL1pH6XQ,22912
+gentem/utils/__init__.py,sha256=TJuXgn7gV-zF8HZuQv3uU-BlwlU1mJpiBDYoeliCFWo,283
+gentem/utils/validators.py,sha256=lFDd1Qn-F2Npyq0illN4vI1SehKxf2qm2bIeWd3mwHM,4389
+gentem-0.1.3.dist-info/licenses/LICENSE,sha256=ng7Oliq_MR4vJnb76Dg2QccUXSozR4-bIRzNTOvtGUc,1086
+gentem-0.1.3.dist-info/METADATA,sha256=EE6QeyVV8gQgEX-0jFBF3XW-sTz_04HCeMU_bqmSAEE,5095
+gentem-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gentem-0.1.3.dist-info/entry_points.txt,sha256=M2X3uoUyPS1rcKCwy2hpT3PT1KyAhoOXCfvGoxj0NLM,43
+gentem-0.1.3.dist-info/top_level.txt,sha256=kGBfHc-pTzlx-A68GISTSLXtBd3__eBad_zXoBW4-wA,7
+gentem-0.1.3.dist-info/RECORD,,

gentem-0.1.3.dist-info/WHEEL

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

gentem-0.1.3.dist-info/entry_points.txt

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

gentem-0.1.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abu Bakr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gentem-0.1.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+gentem