relm 0.1.1__py3-none-any.whl

relm/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

relm/core.py

@@ -0,0 +1,75 @@
+import os
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional
+
+@dataclass
+class Project:
+    name: str
+    version: str
+    path: Path
+    description: Optional[str] = None
+
+    @property
+    def pyproject_path(self) -> Path:
+        return self.path / "pyproject.toml"
+
+    def __str__(self) -> str:
+        return f"{self.name} (v{self.version}) - {self.path}"
+
+def load_project(path: Path) -> Optional[Project]:
+    """
+    Loads a project from a directory if it contains a valid pyproject.toml.
+    """
+    pyproject_file = path / "pyproject.toml"
+    if not pyproject_file.exists():
+        return None
+
+    try:
+        with open(pyproject_file, "rb") as f:
+            data = tomllib.load(f)
+        
+        project_data = data.get("project", {})
+        name = project_data.get("name")
+        version = project_data.get("version")
+        description = project_data.get("description")
+
+        if name and version:
+            return Project(
+                name=name,
+                version=version,
+                path=path,
+                description=description
+            )
+    except Exception as e:
+        # We might want to log this error in a real app
+        pass
+    
+    return None
+
+def find_projects(root_path: Path) -> List[Project]:
+    """
+    Scans the immediate subdirectories of root_path for valid projects.
+    """
+    projects = []
+    if not root_path.exists() or not root_path.is_dir():
+        return projects
+
+    # Check if the root itself is a project
+    root_project = load_project(root_path)
+    if root_project:
+        projects.append(root_project)
+
+    # Check subdirectories
+    for item in root_path.iterdir():
+        if item.is_dir() and item != root_path:
+            # Avoid recursing too deep or checking hidden dirs for now
+            if item.name.startswith("."):
+                continue
+            
+            project = load_project(item)
+            if project:
+                projects.append(project)
+    
+    return sorted(projects, key=lambda p: p.name)

relm/git_ops.py

@@ -0,0 +1,85 @@
+import subprocess
+from pathlib import Path
+from typing import List
+
+def run_git_command(args: List[str], cwd: Path) -> str:
+    """
+    Runs a git command in the specified directory.
+    Raises subprocess.CalledProcessError on failure.
+    """
+    result = subprocess.run(
+        ["git"] + args,
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+        check=True
+    )
+    return result.stdout.strip()
+
+def is_git_clean(path: Path) -> bool:
+    """
+    Checks if the git repository is clean (no uncommitted changes).
+    """
+    try:
+        # update-index -q --refresh is good practice before diff-index
+        subprocess.run(["git", "update-index", "-q", "--refresh"], cwd=path, check=False)
+        # check for unstaged changes
+        subprocess.run(["git", "diff-files", "--quiet"], cwd=path, check=True)
+        # check for staged changes
+        subprocess.run(["git", "diff-index", "--cached", "--quiet", "HEAD", "--"], cwd=path, check=True)
+        return True
+    except subprocess.CalledProcessError:
+        return False
+
+def git_add(path: Path, files: List[str]):
+    run_git_command(["add"] + files, cwd=path)
+
+def git_commit(path: Path, message: str):
+    run_git_command(["commit", "-m", message], cwd=path)
+
+def git_tag(path: Path, tag_name: str, message: str = None):
+    args = ["tag", tag_name]
+    if message:
+        args.extend(["-m", message])
+    run_git_command(args, cwd=path)
+
+def git_push(path: Path):
+    run_git_command(["push"], cwd=path)
+    run_git_command(["push", "--tags"], cwd=path)
+
+def git_fetch_tags(path: Path):
+    """
+    Fetches tags from the remote to ensure local knowledge is up to date.
+    """
+    run_git_command(["fetch", "--tags"], cwd=path)
+
+def git_tag_exists(path: Path, tag_name: str) -> bool:
+    """
+    Checks if a specific tag exists locally.
+    """
+    try:
+        # git rev-parse -q --verify "refs/tags/v1.0.0"
+        run_git_command(["rev-parse", "-q", "--verify", f"refs/tags/{tag_name}"], cwd=path)
+        return True
+    except subprocess.CalledProcessError:
+        return False
+
+def git_has_changes(path: Path, tag_name: str) -> bool:
+    """
+    Checks if there are changes between the given tag and HEAD.
+    Returns True if changes exist, False otherwise.
+    """
+    try:
+        # git diff --quiet tag_name HEAD -- .
+        # If exit code is 1, there are changes. If 0, no changes.
+        # We use check=True which raises error on non-zero... wait.
+        # diff --quiet returns 1 if diffs found. So we want to catch the error.
+        
+        subprocess.run(
+            ["git", "diff", "--quiet", tag_name, "HEAD", "--", "."],
+            cwd=path,
+            check=True
+        )
+        return False # Exit code 0 means NO differences
+    except subprocess.CalledProcessError:
+        return True # Exit code 1 means differences exist (or error, but usually diffs)

relm/main.py

@@ -0,0 +1,108 @@
+import argparse
+import sys
+from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from .core import find_projects
+from .release import perform_release
+
+console = Console()
+
+def list_projects(path: Path):
+    projects = find_projects(path)
+    if not projects:
+        console.print("[yellow]No projects found in this directory.[/yellow]")
+        return
+
+    table = Table(title=f"Found {len(projects)} Projects")
+    table.add_column("Name", style="cyan", no_wrap=True)
+    table.add_column("Version", style="magenta")
+    table.add_column("Path", style="green")
+    table.add_column("Description")
+
+    for project in projects:
+        table.add_row(
+            project.name,
+            project.version,
+            str(project.path),
+            project.description or ""
+        )
+
+    console.print(table)
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Manage releases and versioning for local Python projects."
+    )
+    parser.add_argument(
+        "--path",
+        default=".",
+        help="Path to the root directory containing projects (default: current dir)."
+    )
+    
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    
+    # List command
+    list_parser = subparsers.add_parser("list", help="List all discovered projects")
+    
+    # Release command
+    release_parser = subparsers.add_parser("release", help="Release a new version of a project")
+    release_parser.add_argument("project_name", help="Name of the project to release (must match pyproject.toml name)")
+    release_parser.add_argument("type", choices=["major", "minor", "patch"], default="patch", nargs="?", help="Type of version bump")
+    release_parser.add_argument("-y", "--yes", action="store_true", help="Skip confirmation prompts (assume yes)")
+
+    args = parser.parse_args()
+    root_path = Path(args.path).resolve()
+
+    if args.command == "list":
+        list_projects(root_path)
+    
+    elif args.command == "release":
+        all_projects = find_projects(root_path)
+        
+        target_projects = []
+        check_changes_flag = False
+
+        if args.project_name == "all":
+            target_projects = all_projects
+            check_changes_flag = True
+            console.print(f"[bold]Running Bulk Release on {len(target_projects)} projects...[/bold]")
+        else:
+            # Find single project
+            target = next((p for p in all_projects if p.name == args.project_name), None)
+            if not target:
+                console.print(f"[red]Project '{args.project_name}' not found in {root_path}[/red]")
+                sys.exit(1)
+            target_projects = [target]
+
+        # Execute releases
+        results = {"released": [], "skipped": [], "failed": []}
+
+        for project in target_projects:
+            # Skip template/meta repos if needed, but git_has_changes handles most logic
+            try:
+                success = perform_release(
+                    project, 
+                    args.type, 
+                    yes_mode=args.yes, 
+                    check_changes=check_changes_flag
+                )
+                if success:
+                    results["released"].append(project.name)
+                else:
+                    results["skipped"].append(project.name)
+            except Exception as e:
+                console.print(f"[red]Critical error releasing {project.name}: {e}[/red]")
+                results["failed"].append(project.name)
+
+        # Summary
+        if args.project_name == "all":
+            console.rule("Bulk Release Summary")
+            console.print(f"[green]Released: {len(results['released'])}[/green] {results['released']}")
+            console.print(f"[yellow]Skipped:  {len(results['skipped'])}[/yellow]")
+            if results["failed"]:
+                console.print(f"[red]Failed:   {len(results['failed'])}[/red] {results['failed']}")
+
+if __name__ == "__main__":
+    main()

relm/release.py

@@ -0,0 +1,166 @@
+import sys
+import subprocess
+from pathlib import Path
+from typing import Literal
+
+from rich.console import Console
+from rich.prompt import Confirm, Prompt
+
+from .core import Project
+from .versioning import bump_version_string, update_file_content, update_version_tests
+from .git_ops import is_git_clean, git_add, git_commit, git_tag, git_push, git_fetch_tags, git_tag_exists, git_has_changes
+
+console = Console()
+
+def run_tests(project_path: Path) -> bool:
+    """
+    Runs pytest in the project directory. Returns True if successful.
+    """
+    # Check if pytest is installed/available?
+    # We assume the user has the env set up correctly or it's in path.
+    console.print("[bold blue]Running tests...[/bold blue]")
+    try:
+        # We use sys.executable -m pytest to use the same env
+        subprocess.run(
+            [sys.executable, "-m", "pytest"],
+            cwd=project_path,
+            check=True
+        )
+        return True
+    except subprocess.CalledProcessError:
+        return False
+    except FileNotFoundError:
+        console.print("[yellow]pytest not found. Skipping tests.[/yellow]")
+        return True # Treat missing pytest as "pass" (or warn?) - safer to warn and pass for now
+
+def revert_changes(project_path: Path):
+    """
+    Reverts local changes using git checkout.
+    """
+    console.print("[yellow]Reverting changes...[/yellow]")
+    try:
+        subprocess.run(["git", "checkout", "."], cwd=project_path, check=True)
+    except Exception as e:
+        console.print(f"[red]Failed to revert changes: {e}[/red]")
+
+def perform_release(project: Project, part: Literal['major', 'minor', 'patch'], yes_mode: bool = False, check_changes: bool = False) -> bool:
+    console.rule(f"Releasing {project.name}")
+    
+    # 0. Fetch Tags & Check State
+    console.print("[dim]Fetching remote tags...[/dim]")
+    try:
+        git_fetch_tags(project.path)
+    except Exception:
+        console.print("[yellow]Warning: Could not fetch remote tags. Proceeding with local info.[/yellow]")
+
+    current_version_tag = f"v{project.version}"
+    is_already_tagged = git_tag_exists(project.path, current_version_tag)
+    
+    # Smart Skip Logic
+    if check_changes and is_already_tagged:
+        if not git_has_changes(project.path, current_version_tag):
+            console.print(f"[dim]No changes detected since {current_version_tag}. Skipping.[/dim]")
+            return False
+
+    should_bump = True
+    target_version = project.version # Default to current if not bumping
+    
+    if not is_already_tagged:
+        console.print(f"[yellow]Notice: Current version [bold]{project.version}[/bold] is NOT tagged locally.[/yellow]")
+        # If yes_mode is on, we default to RETRY (True), i.e. skip bump
+        if yes_mode or Confirm.ask(f"Retry release for v{project.version} (skip bump)?", default=True):
+            should_bump = False
+            target_version = project.version
+    
+    # 1. Check Git Cleanliness
+    if not is_git_clean(project.path):
+        console.print("[red]Error: Git repository is not clean. Commit or stash changes first.[/red]")
+        # We could potentially auto-commit if yes_mode is on, but that's risky.
+        return False
+
+    # 2. Calculate New Version (if bumping)
+    if should_bump:
+        try:
+            target_version = bump_version_string(project.version, part)
+            console.print(f"Current version: [cyan]{project.version}[/cyan]")
+            console.print(f"New version:     [green]{target_version}[/green]")
+        except ValueError as e:
+            console.print(f"[red]Error parsing version: {e}[/red]")
+            return False
+    else:
+         console.print(f"Releasing existing version: [green]{target_version}[/green]")
+
+    
+    if not yes_mode and not Confirm.ask("Proceed with release?"):
+        console.print("[yellow]Release cancelled.[/yellow]")
+        return False
+
+    # 3. Update Files (Only if bumping)
+    if should_bump:
+        console.print("[bold blue]Updating files...[/bold blue]")
+        files_updated = []
+        
+        # Update pyproject.toml
+        if update_file_content(project.pyproject_path, project.version, target_version):
+            files_updated.append("pyproject.toml")
+        
+        # Update __init__.py
+        # Try src/{name}/__init__.py first
+        init_path = project.path / "src" / project.name.replace("-", "_") / "__init__.py"
+        if not init_path.exists():
+             # Try {name}/__init__.py
+             init_path = project.path / project.name.replace("-", "_") / "__init__.py"
+        
+        if init_path.exists():
+            if update_file_content(init_path, project.version, target_version):
+                files_updated.append(str(init_path.relative_to(project.path)))
+        
+        # Update Tests (Hardcoded versions)
+        updated_tests = update_version_tests(project.path, project.version, target_version)
+        if updated_tests:
+            console.print(f"[green]Automatically updated version assertions in {len(updated_tests)} test files.[/green]")
+            files_updated.extend(updated_tests)
+
+        if not files_updated:
+            console.print("[red]No files were updated! Check version strings.[/red]")
+            return False
+            
+        # 4. Run Tests Locally
+        if not run_tests(project.path):
+            console.print("[bold red]Tests failed! Aborting release.[/bold red]")
+            if yes_mode or Confirm.ask("Revert changes to files?", default=True):
+                revert_changes(project.path)
+            return False
+
+        # 5. Git Commit
+        console.print("[bold blue]Committing...[/bold blue]")
+        try:
+            git_add(project.path, files_updated)
+            git_commit(project.path, f"release: bump version to {target_version}")
+        except Exception as e:
+            console.print(f"[red]Git commit error: {e}[/red]")
+            return False
+
+    # 6. Tag (Always needed)
+    # We double check if tag exists now, just in case
+    if git_tag_exists(project.path, f"v{target_version}"):
+         console.print(f"[yellow]Tag v{target_version} already exists locally. Skipping creation.[/yellow]")
+    else:
+        console.print(f"[bold blue]Tagging v{target_version}...[/bold blue]")
+        try:
+            git_tag(project.path, f"v{target_version}", f"Release v{target_version}")
+        except Exception as e:
+            console.print(f"[red]Git tag error: {e}[/red]")
+            return False
+
+    # 7. Push
+    if yes_mode or Confirm.ask("Push changes to remote? (This will trigger the GitHub Action release)"):
+        try:
+            git_push(project.path)
+        except Exception as e:
+            console.print(f"[red]Push error: {e}[/red]")
+            return False
+
+    console.print(f"[bold green]Successfully tagged and pushed {project.name} v{target_version}![/bold green]")
+    console.print("[dim]The GitHub Action workflow should now handle the PyPI release.[/dim]")
+    return True

relm/versioning.py

@@ -0,0 +1,111 @@
+import re
+from pathlib import Path
+from typing import Tuple, List
+
+def parse_version(version: str) -> Tuple[int, int, int]:
+    """
+    Parses a version string 'x.y.z' into a tuple of integers.
+    """
+    try:
+        parts = version.split('.')
+        if len(parts) < 3:
+            # Handle cases like '0.1' -> '0.1.0'
+            parts.extend(['0'] * (3 - len(parts)))
+        return int(parts[0]), int(parts[1]), int(parts[2])
+    except ValueError:
+        raise ValueError(f"Invalid version format: {version}")
+
+def bump_version_string(version: str, part: str) -> str:
+    """
+    Bumps the version string based on the part ('major', 'minor', 'patch').
+    """
+    major, minor, patch = parse_version(version)
+    
+    if part == 'major':
+        major += 1
+        minor = 0
+        patch = 0
+    elif part == 'minor':
+        minor += 1
+        patch = 0
+    elif part == 'patch':
+        patch += 1
+    else:
+        raise ValueError(f"Invalid bump part: {part}")
+        
+    return f"{major}.{minor}.{patch}"
+
+def update_file_content(path: Path, old_version: str, new_version: str) -> bool:
+    """
+    Replaces occurrences of old_version with new_version in the file at path.
+    Returns True if changes were made.
+    """
+    if not path.exists():
+        return False
+        
+    try:
+        content = path.read_text(encoding="utf-8")
+        
+        new_content = content
+        
+        # Pattern for pyproject.toml: version = "1.0.0"
+        toml_pattern = re.compile(rf'version\s*=\s*"{re.escape(old_version)}"')
+        if toml_pattern.search(content):
+            new_content = toml_pattern.sub(f'version = "{new_version}"', new_content)
+            
+        # Pattern for __init__.py: __version__ = "1.0.0"
+        init_pattern = re.compile(rf'__version__\s*=\s*"{re.escape(old_version)}"')
+        if init_pattern.search(content):
+            new_content = init_pattern.sub(f'__version__ = "{new_version}"', new_content)
+            
+        if new_content != content:
+            path.write_text(new_content, encoding="utf-8")
+            return True
+            
+    except Exception as e:
+        print(f"Error updating {path}: {e}")
+        return False
+        
+    return False
+
+def update_version_tests(project_path: Path, old_version: str, new_version: str) -> List[str]:
+    """
+    Scans the 'tests' directory for files containing the old version string
+    in an assertion context and updates them. returns list of updated files.
+    """
+    updated_files = []
+    tests_dir = project_path / "tests"
+    if not tests_dir.exists():
+        return updated_files
+
+    # Regex to match: assert ... == "1.2.3" or assert "1.2.3" == ...
+    # We are generous with whitespace
+    # This might need refinement but covers standard cases.
+    # We actually just look for the literal string "1.2.3" inside test files
+    # because replacing it strictly in context is safer than broad replace, 
+    # but parsing python AST is too heavy. 
+    # Let's look for the exact string "old_version" to be safe, 
+    # but only if it looks like a version check? 
+    # actually, if a test file has the version string "1.0.0", it is 99% likely the version check.
+    
+    for test_file in tests_dir.rglob("*.py"):
+        try:
+            content = test_file.read_text(encoding="utf-8")
+            if old_version in content:
+                # Check if it's surrounded by quotes to avoid partial matches
+                # e.g. matching "1.0" in "1.0.0" (though old_version is usually full)
+                
+                # Simple string replace for "old_version" -> "new_version"
+                # We use quotes to ensure we match string literals
+                if f'"{old_version}"' in content:
+                    new_content = content.replace(f'"{old_version}"', f'"{new_version}"')
+                    test_file.write_text(new_content, encoding="utf-8")
+                    updated_files.append(str(test_file.relative_to(project_path)))
+                elif f"'{old_version}'" in content:
+                    new_content = content.replace(f"'{old_version}'", f"'{new_version}'")
+                    test_file.write_text(new_content, encoding="utf-8")
+                    updated_files.append(str(test_file.relative_to(project_path)))
+        except Exception:
+            pass
+            
+    return updated_files

relm-0.1.1.dist-info/METADATA

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: relm
+Version: 0.1.1
+Summary: A unified CLI tool to manage versioning, git, and PyPI releases for multiple projects.
+Author-email: dhruv13x <dhruv13x@gmail.com>
+License: MIT © dhruv13x
+Project-URL: Homepage, https://github.com/dhruv13x/relm
+Project-URL: Source, https://github.com/dhruv13x/relm
+Project-URL: Issues, https://github.com/dhruv13x/relm/issues
+Keywords: cli,release,versioning,automation,pypi,git
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: tomli; python_version < "3.11"
+Requires-Dist: rich>=13.0.0
+Requires-Dist: rich-argparse>=1.0.0
+Requires-Dist: build>=1.0.0
+Requires-Dist: twine>=4.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
+Requires-Dist: pytest-timeout>=2.2.0; extra == "dev"
+Requires-Dist: pytest-json-report>=1.5.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.10.0; extra == "dev"
+Requires-Dist: pyfakefs>=5.0.0; extra == "dev"
+Requires-Dist: ruff>=0.6.0; extra == "dev"
+Requires-Dist: black>=24.3.0; extra == "dev"
+Requires-Dist: mypy>=1.11.0; extra == "dev"
+Requires-Dist: PyYAML>=6.0; extra == "dev"
+Requires-Dist: types-PyYAML>=6.0; extra == "dev"
+
+# Repo Manager
+
+A unified CLI tool to automate versioning, git operations, and PyPI releases for the dhruv13x tool suite.
+
+## Features
+
+- **Project Discovery**: Automatically detects Python projects with `pyproject.toml`.
+- **Smart Versioning**: Bumps versions (major, minor, patch) in `pyproject.toml` and `__init__.py`.
+- **Git Automation**: Stages, commits, and pushes release changes.
+- **PyPI Release**: Builds and uploads packages to PyPI.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```bash
+relm --help
+```

relm-0.1.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+relm/__init__.py,sha256=rnObPjuBcEStqSO0S6gsdS_ot8ITOQjVj_-P1LUUYpg,22
+relm/core.py,sha256=EqsB9DaUD987OZXOQ2bZXoW5yMolkJ27ExNhtpl7X_Q,2080
+relm/git_ops.py,sha256=bL0k2fiW7IOBUtpY6lb_wBaCkmUUxRZ11pEnnoKqoa4,2871
+relm/main.py,sha256=P78DY4QSABudY16CkYoPrWbSNA0YWcXHNTZ4SvkbedM,3973
+relm/release.py,sha256=xuJUkaSVsazQguB1tBVfEROCzOJInVXPQSzEvCzn_n8,6947
+relm/versioning.py,sha256=D4_MoPHd31mPGe0EBeHmYEOUDMYMh3ySBI2CrT3EZV0,4337
+relm-0.1.1.dist-info/METADATA,sha256=uFYKrDxqOb0qDaa8OzXQcEUpCGkc9WGGH1Ut8gEtYqI,2042
+relm-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+relm-0.1.1.dist-info/entry_points.txt,sha256=mt1ZiWqOl3MbE8ZrRhryrxE1owGgNH-v84px6w23pmg,40
+relm-0.1.1.dist-info/top_level.txt,sha256=0-YNy4YWXcpbBb5DdW6wnOzqYGz2PMhQC0x2g85-MPE,5
+relm-0.1.1.dist-info/RECORD,,

relm-0.1.1.dist-info/WHEEL

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

relm-0.1.1.dist-info/entry_points.txt

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

relm-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+relm