tempit-manager 0.0__tar.gz

tempit_manager-0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 idirxv
+
+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.

tempit_manager-0.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: tempit-manager
+Version: 0.0
+Summary: Manage and jump into temporary working directories
+License-File: LICENSE
+Author: Idir Oura
+Author-email: idir.oura@protonmail.com
+Requires-Python: >=3.10,<3.14
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: humanize
+Requires-Dist: rich
+Requires-Dist: typer
+Description-Content-Type: text/markdown
+
+# Tempit - Temporary Directory Manager
+
+Tempit is a command-line utility and shell helper that lets you create, track, and jump to temporary directories without losing them.
+## Features
+
+- Create temporary directories with optional prefixes.
+- List tracked directories with size, creation time, age, and file counts.
+- Jump to a directory by its number.
+- Remove individual directories or clean them all.
+- Works via shell integration.
+
+## Installation
+
+### Using pip
+
+```bash
+pip install tempit-manager
+```
+
+### Shell integration
+
+Add the following line to your shell startup file (`~/.bashrc` or `~/.zshrc`):
+
+```bash
+# Bash
+eval "$(tempit init bash)"
+
+# Zsh
+eval "$(tempit init zsh)"
+```
+
+## Usage
+
+### CLI commands
+
+```bash
+tempit create [prefix]
+tempit list
+tempit remove <number>
+tempit clean-all
+tempit init <shell>
+```
+
+### Aliases (after shell init)
+
+| Alias | Description |
+|-------|-------------|
+| `tempc [prefix]` | Create a new temporary directory and cd into it |
+| `tempg <number>` | Jump to a directory by its number |
+| `templ` | List tracked temporary directories |
+| `temprm <number>` | Remove a tracked temporary directory by its number |
+| `tempclean` | Remove all tracked temporary directories |
+
+## License
+
+[MIT](LICENSE)
+

tempit_manager-0.0/README.md

@@ -0,0 +1,56 @@
+# Tempit - Temporary Directory Manager
+
+Tempit is a command-line utility and shell helper that lets you create, track, and jump to temporary directories without losing them.
+## Features
+
+- Create temporary directories with optional prefixes.
+- List tracked directories with size, creation time, age, and file counts.
+- Jump to a directory by its number.
+- Remove individual directories or clean them all.
+- Works via shell integration.
+
+## Installation
+
+### Using pip
+
+```bash
+pip install tempit-manager
+```
+
+### Shell integration
+
+Add the following line to your shell startup file (`~/.bashrc` or `~/.zshrc`):
+
+```bash
+# Bash
+eval "$(tempit init bash)"
+
+# Zsh
+eval "$(tempit init zsh)"
+```
+
+## Usage
+
+### CLI commands
+
+```bash
+tempit create [prefix]
+tempit list
+tempit remove <number>
+tempit clean-all
+tempit init <shell>
+```
+
+### Aliases (after shell init)
+
+| Alias | Description |
+|-------|-------------|
+| `tempc [prefix]` | Create a new temporary directory and cd into it |
+| `tempg <number>` | Jump to a directory by its number |
+| `templ` | List tracked temporary directories |
+| `temprm <number>` | Remove a tracked temporary directory by its number |
+| `tempclean` | Remove all tracked temporary directories |
+
+## License
+
+[MIT](LICENSE)

tempit_manager-0.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["poetry-core>=2.0.0", "poetry-dynamic-versioning>=1.0.0,<2.0.0"]
+build-backend = "poetry_dynamic_versioning.backend"
+
+[project]
+name = "tempit-manager"
+version = "0.0"
+description = "Manage and jump into temporary working directories"
+readme = "README.md"
+requires-python = ">=3.10,<3.14"
+authors = [{ name = "Idir Oura", email = "idir.oura@protonmail.com" }]
+dependencies = [
+    "humanize",
+    "rich",
+    "typer",
+]
+
+[project.scripts]
+tempit = "tempit.cli:main"
+
+[tool.poetry]
+packages = [{ include = "tempit" }]
+include = [
+  { path = "tempit/shell/init.sh" }
+]
+
+[tool.poetry-dynamic-versioning]
+enable = true
+vcs = "git"
+
+[tool.poetry.group.dev.dependencies]
+pytest = ">=8.4.2,<9.0.0"
+flake8 = ">=7.3.0,<8.0.0"
+ruff = ">=0.13.0,<0.14.0"
+mypy = ">=1.18.1,<2.0.0"
+pylint = ">=3.3.8,<4.0.0"

tempit_manager-0.0/tempit/cli.py

@@ -0,0 +1,65 @@
+"""CLI entry point for the tempit application."""
+
+import logging
+
+import typer
+
+from tempit.core import TempitManager
+
+app = typer.Typer(add_completion=False, help="CLI for the tempit application.")
+
+
+def get_manager() -> TempitManager:
+    """Helper pour initialiser le manager et gérer les erreurs globales."""
+    try:
+        return TempitManager()
+    except (IOError, OSError) as e:
+        logging.error("An error occurred: %s", e)
+        raise typer.Exit(code=1)
+
+
+@app.command("create")
+def create_dir(name: str = typer.Argument(..., help="Name of the temporary directory.")):
+    """Create a new temporary directory."""
+    typer.echo(get_manager().create(name))
+
+
+@app.command("init")
+def init_shell(shell: str = typer.Argument(..., help="Shell name (e.g., bash, zsh).")):
+    """Initialize Tempit in the current shell."""
+    get_manager().init_shell(shell)
+
+
+@app.command("list")
+def list_dirs():
+    """List all tracked temporary directories."""
+    get_manager().print_directories()
+
+
+@app.command("remove")
+def remove_dir(number: int = typer.Argument(..., help="Number of the directory to remove.")):
+    """Remove a tracked temporary directory by its number."""
+    if not get_manager().remove(number):
+        raise typer.Exit(code=1)
+
+
+@app.command("clean-all")
+def clean_all():
+    """Remove all tracked temporary directories."""
+    get_manager().clean_all_directories()
+
+
+@app.command("path", hidden=True)
+def get_path(number: int):
+    """Get directory path by number."""
+    typer.echo(get_manager().get_path_by_number(number))
+
+
+def main():
+    """Run the tempit CLI application."""
+    logging.basicConfig(level=logging.WARNING, format="%(levelname)s: %(message)s")
+    app()
+
+
+if __name__ == "__main__":
+    main()

tempit_manager-0.0/tempit/core.py

@@ -0,0 +1,93 @@
+"""Core module for the tempit application."""
+
+import logging
+from pathlib import Path
+
+from tempit.render import DirectoryRenderer
+from tempit.services import DirectoryService
+from tempit.stats import calculate_stats
+from tempit.storage import DirectoryStorage
+
+
+class TempitManager:
+    """Main manager class for temporary directory operations."""
+
+    def __init__(self, storage_file: Path = Path("/tmp/tempit_dirs.json")):
+        """Initialize the TempitManager with dependency injection."""
+        self.logger = logging.getLogger(__name__)
+        self.storage = DirectoryStorage(storage_file)
+        self.service = DirectoryService()
+        self.renderer = DirectoryRenderer()
+
+    def init_shell(self, shell: str) -> None:
+        """Initialize Tempit in the current shell."""
+        if shell in ["bash", "zsh"]:
+            init_script_path = Path(__file__).parent / "shell" / "init.sh"
+            try:
+                with init_script_path.open("r", encoding="utf-8") as f:
+                    print(f.read())
+            except FileNotFoundError:
+                self.logger.error("Error reading initialization script: %s", init_script_path)
+        else:
+            self.logger.error("Unsupported shell: %s", shell)
+
+    def create(self, prefix: str = "tempit") -> Path:
+        """Create a new temporary directory and track it."""
+        try:
+            dir_info = self.service.create_temp_directory(prefix)
+            self.storage.add_directory(dir_info)
+            self.logger.info("Created temporary directory: %s", dir_info.path)
+            return dir_info.path
+        except (IOError, OSError) as e:
+            self.logger.error("Error creating temporary directory: %s", e)
+            raise
+
+    def remove(self, number: int) -> bool:
+        """Remove a tracked temporary directory by its number."""
+        try:
+            self.storage.prune_stale()
+            dir_path = self.storage.get_path_by_number(number)
+            if dir_path is None:
+                return False
+            success = self.service.remove_directory(dir_path)
+            if success:
+                self.storage.remove_directory(dir_path)
+                self.logger.info("Removed temporary directory: %s", dir_path)
+                return True
+            return False
+        except (IOError, OSError) as e:
+            self.logger.error("Error removing temporary directory: %s", e)
+            return False
+
+    def print_directories(self) -> None:
+        """Print a formatted table of tracked temporary directories."""
+        self.storage.prune_stale()
+        directories = self.storage.get_all_directories()
+        all_entries = [(d, calculate_stats(d)) for d in directories]
+        entries = [(d, s) for d, s in all_entries if s is not None]
+        self.renderer.render_directory_list(entries)
+
+    def get_path_by_number(self, number: int) -> Path | None:
+        """Return the path for a tracked directory by its number."""
+        self.storage.prune_stale()
+        return self.storage.get_path_by_number(number)
+
+    def clean_all_directories(self) -> None:
+        """Remove all tracked temporary directories."""
+        self.storage.prune_stale()
+        directories = self.storage.get_all_directories()
+
+        if not directories:
+            self.logger.warning("No temporary directories found.")
+            return
+
+        removed_count = 0
+        for dir_info in directories:
+            try:
+                if self.service.remove_directory(dir_info.path):
+                    self.storage.remove_directory(dir_info.path)
+                    removed_count += 1
+            except (IOError, OSError) as e:
+                self.logger.error("Error removing directory %s: %s", dir_info.path, e)
+
+        self.logger.info("Removed %s temporary directories.", removed_count)

tempit_manager-0.0/tempit/models.py

@@ -0,0 +1,40 @@
+"""Data models for the tempit application."""
+
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict
+
+
+@dataclass
+class DirectoryInfo:
+    """Data model for temporary directory information."""
+
+    path: Path
+    created: datetime
+    prefix: str = "tempit"
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        data = asdict(self)
+        data["created"] = self.created.isoformat()
+        return data
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "DirectoryInfo":
+        """Create instance from dictionary (JSON deserialization)."""
+        data = data.copy()
+        data["created"] = datetime.fromisoformat(data["created"])
+        data["path"] = Path(data["path"])
+        return cls(**data)
+
+
+@dataclass
+class DirectoryStats:
+    """Runtime statistics for a directory (not stored in JSON)."""
+
+    size_bytes: int
+    human_size: str
+    file_count: int
+    dir_count: int
+    age: str

tempit_manager-0.0/tempit/render.py

@@ -0,0 +1,73 @@
+"""Render directory information as a rich table."""
+
+import sys
+from typing import List, Tuple
+
+from rich.console import Console
+from rich.table import Table
+
+from tempit.models import DirectoryInfo, DirectoryStats
+
+
+class DirectoryRenderer:  # pylint: disable=too-few-public-methods
+    """Renders (DirectoryInfo, DirectoryStats) pairs as a rich table. No external dependencies."""
+
+    def render_directory_list(
+        self,
+        entries: List[Tuple[DirectoryInfo, DirectoryStats]],
+        title: str = "Temporary Directories",
+    ) -> None:
+        """Render a list of (info, stats) pairs as a rich table."""
+        console = Console(file=sys.stdout, width=None if sys.stdout.isatty() else 220)
+
+        if not entries:
+            console.print("[yellow]No temporary directories found.[/yellow]")
+            return
+
+        table = Table(title=title, show_header=True, header_style="bold white")
+        table.add_column("#", justify="center", style="bold white")
+        table.add_column("Name", style="bold cyan", no_wrap=True)
+        table.add_column("Path")
+        table.add_column("Size")
+        table.add_column("Created")
+        table.add_column("Age")
+        table.add_column("Contents")
+
+        for i, (dir_info, stats) in enumerate(entries):
+            table.add_row(*self._create_table_row(dir_info, stats, i))
+
+        console.print()
+        console.print(table)
+        console.print()
+
+    def _create_table_row(
+        self,
+        dir_info: DirectoryInfo,
+        stats: DirectoryStats,
+        index: int,
+    ) -> List[str]:
+        created_str = dir_info.created.strftime("%Y-%m-%d %H:%M")
+
+        if stats.size_bytes > 100 * 1024 * 1024:
+            size_markup = f"[red]{stats.human_size}[/red]"
+        elif stats.size_bytes > 10 * 1024 * 1024:
+            size_markup = f"[yellow]{stats.human_size}[/yellow]"
+        else:
+            size_markup = f"[green]{stats.human_size}[/green]"
+
+        if "day" in stats.age or "month" in stats.age or "year" in stats.age:
+            age_markup = f"[yellow]{stats.age}[/yellow]"
+        else:
+            age_markup = f"[green]{stats.age}[/green]"
+
+        contents = f"[blue]{stats.file_count}[/blue] files, [blue]{stats.dir_count}[/blue] dirs"
+
+        return [
+            str(index + 1),
+            dir_info.prefix,
+            str(dir_info.path),
+            size_markup,
+            created_str,
+            age_markup,
+            contents,
+        ]

tempit_manager-0.0/tempit/services.py

@@ -0,0 +1,43 @@
+"""Service layer for directory operations."""
+
+import logging
+import shutil
+import tempfile
+from datetime import datetime
+from pathlib import Path
+
+from tempit.models import DirectoryInfo
+
+
+class DirectoryService:
+    """Service for directory operations."""
+
+    def __init__(self, temp_base_dir: Path = Path("/tmp")):
+        """Initialize the directory service."""
+        self.temp_base_dir = temp_base_dir
+        self.logger = logging.getLogger(__name__)
+
+    def create_temp_directory(self, prefix: str = "tempit") -> DirectoryInfo:
+        """Create a new temporary directory and return its info."""
+        try:
+            temp_dir = tempfile.mkdtemp(prefix=f"{prefix}_", dir=self.temp_base_dir)
+
+            return DirectoryInfo(
+                path=Path(temp_dir), created=datetime.now(), prefix=prefix
+            )
+        except (IOError, OSError) as e:
+            self.logger.error("Error creating temporary directory: %s", e)
+            raise
+
+    def remove_directory(self, path: Path) -> bool:
+        """Remove a directory from the filesystem."""
+        try:
+            if path.exists():
+                shutil.rmtree(path)
+                self.logger.info("Removed directory: %s", path)
+                return True
+            self.logger.warning("Directory does not exist: %s", path)
+            return False
+        except (IOError, OSError) as e:
+            self.logger.error("Error removing directory %s: %s", path, e)
+            return False

tempit_manager-0.0/tempit/shell/init.sh

@@ -0,0 +1,38 @@
+# shellcheck shell=bash
+__TEMPIT_EXE="$(command -v tempit)"
+
+if [[ -z "$__TEMPIT_EXE" ]]; then
+  echo "tempit: executable not found in PATH" >&2
+else
+  _tempit() {
+    case "$1" in
+      create|-c)
+        shift
+        local __path
+        __path="$(command "$__TEMPIT_EXE" create "$@")" || return $?
+        if [[ -n "$__path" && -d "$__path" ]]; then
+          cd "$__path" || return $?
+        fi
+        ;;
+      go|-g)
+        shift
+        local __path
+        __path="$(command "$__TEMPIT_EXE" path "$@")" || return $?
+        if [[ -n "$__path" && -d "$__path" ]]; then
+          cd "$__path" || return $?
+        fi
+        ;;
+      *)
+        command "$__TEMPIT_EXE" "$@"
+        ;;
+    esac
+  }
+
+    # Aliases
+    alias tempc="_tempit create"
+    alias tempg="_tempit go"
+    alias templ="_tempit list"
+    alias temprm="_tempit remove"
+    alias tempclean="_tempit clean-all"
+
+fi

tempit_manager-0.0/tempit/stats.py

@@ -0,0 +1,29 @@
+"""Pure stats calculation for directory information."""
+
+from datetime import datetime
+
+import humanize
+
+from tempit.models import DirectoryInfo, DirectoryStats
+
+
+def calculate_stats(dir_info: DirectoryInfo) -> DirectoryStats | None:
+    """Calculate stats for a directory. Returns None if the path doesn't exist."""
+    dir_path = dir_info.path
+    if not dir_path.exists():
+        return None
+
+    all_entries = list(dir_path.rglob("*"))
+    files = [f for f in all_entries if f.is_file()]
+    dirs = [d for d in all_entries if d.is_dir()]
+    total_size = sum(f.stat().st_size for f in files)
+    file_count = len(files)
+    dir_count = len(dirs)
+
+    return DirectoryStats(
+        size_bytes=total_size,
+        human_size=humanize.naturalsize(total_size, binary=True),
+        file_count=file_count,
+        dir_count=dir_count,
+        age=humanize.naturaltime(datetime.now() - dir_info.created),
+    )

tempit_manager-0.0/tempit/storage.py

@@ -0,0 +1,75 @@
+"""Storage layer for persisting directory information in JSON format."""
+
+import json
+import logging
+from pathlib import Path
+from typing import List
+
+from tempit.models import DirectoryInfo
+
+
+class DirectoryStorage:
+    """Handles JSON-based persistence of directory information."""
+
+    def __init__(self, storage_file: Path = Path("/tmp/tempit_dirs.json")):
+        """Initialize the storage with a JSON file path."""
+        self.storage_file = storage_file
+        self.logger = logging.getLogger(__name__)
+        self._ensure_storage_file()
+
+    def _ensure_storage_file(self) -> None:
+        """Ensure the storage file and its parent directory exist."""
+        self.storage_file.parent.mkdir(parents=True, exist_ok=True)
+        if not self.storage_file.exists():
+            self._write_directories([])
+
+    def _read_directories(self) -> List[DirectoryInfo]:
+        """Read all directories from the JSON storage file."""
+        try:
+            with open(self.storage_file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                return [DirectoryInfo.from_dict(item) for item in data]
+        except (FileNotFoundError, json.JSONDecodeError) as e:
+            self.logger.warning("Error reading storage file: %s", e)
+            return []
+
+    def _write_directories(self, directories: List[DirectoryInfo]) -> None:
+        """Write all directories to the JSON storage file."""
+        try:
+            data = [dir_info.to_dict() for dir_info in directories]
+            with open(self.storage_file, "w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2, default=str)
+        except (IOError, TypeError) as e:
+            self.logger.error("Error writing to storage file: %s", e)
+            raise
+
+    def add_directory(self, directory_info: DirectoryInfo) -> None:
+        """Add a new directory to storage."""
+        directories = self._read_directories()
+        directories.append(directory_info)
+        self._write_directories(directories)
+
+    def get_all_directories(self) -> List[DirectoryInfo]:
+        """Read all stored directory entries. Pure read — no side effects."""
+        return self._read_directories()
+
+    def prune_stale(self) -> None:
+        """Remove entries for directories that no longer exist on the filesystem."""
+        all_dirs = self._read_directories()
+        existing = [d for d in all_dirs if d.path.exists()]
+        if len(existing) != len(all_dirs):
+            self._write_directories(existing)
+            self.logger.info("Pruned %d stale entries.", len(all_dirs) - len(existing))
+
+    def get_path_by_number(self, number: int) -> Path | None:
+        """Get the path of a tracked directory by its 1-based index."""
+        directories = self.get_all_directories()
+        if not directories or not 1 <= number <= len(directories):
+            self.logger.error("Invalid directory number: %s", number)
+            return None
+        return directories[number - 1].path
+
+    def remove_directory(self, path: Path) -> None:
+        """Remove a directory entry from storage by path. Raises on write failure."""
+        directories = self._read_directories()
+        self._write_directories([d for d in directories if d.path != path])