fabricatio 0.2.6__cp39-cp39-win_amd64.whl

fabricatio/core.py

@@ -0,0 +1,181 @@
+"""Core module that contains the Env class for managing event handling."""
+
+from typing import Callable, Optional, Self, overload
+
+from pydantic import BaseModel, ConfigDict, PrivateAttr
+from pymitter import EventEmitter
+
+from fabricatio.config import configs
+from fabricatio.models.events import Event
+
+
+class Env(BaseModel):
+    """Environment class that manages event handling using EventEmitter."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    _ee: EventEmitter = PrivateAttr(
+        default_factory=lambda: EventEmitter(
+            delimiter=configs.pymitter.delimiter,
+            new_listener=configs.pymitter.new_listener_event,
+            max_listeners=configs.pymitter.max_listeners,
+            wildcard=True,
+        )
+    )
+
+    @overload
+    def on(self, event: str | Event, /, ttl: int = -1) -> Self:
+        """
+        Registers an event listener that listens indefinitely or for a specified number of times.
+
+        Args:
+            event (str | Event): The event to listen for.
+            ttl (int): Time-to-live for the listener. If -1, the listener will listen indefinitely.
+
+        Returns:
+            Self: The current instance of Env.
+        """
+        ...
+
+    @overload
+    def on[**P, R](
+        self,
+        event: str | Event,
+        func: Optional[Callable[P, R]] = None,
+        /,
+        ttl: int = -1,
+    ) -> Callable[[Callable[P, R]], Callable[P, R]]:
+        """
+        Registers an event listener with a specific function that listens indefinitely or for a specified number of times.
+
+        Args:
+            event (str | Event): The event to listen for.
+            func (Callable[P, R]): The function to be called when the event is emitted.
+            ttl (int): Time-to-live for the listener. If -1, the listener will listen indefinitely.
+
+        Returns:
+            Callable[[Callable[P, R]], Callable[P, R]]: A decorator that registers the function as an event listener.
+        """
+        ...
+
+    def on[**P, R](
+        self,
+        event: str | Event,
+        func: Optional[Callable[P, R]] = None,
+        /,
+        ttl=-1,
+    ) -> Callable[[Callable[P, R]], Callable[P, R]] | Self:
+        """Registers an event listener with a specific function that listens indefinitely or for a specified number of times.
+
+        Args:
+            event (str | Event): The event to listen for.
+            func (Callable[P, R]): The function to be called when the event is emitted.
+            ttl (int): Time-to-live for the listener. If -1, the listener will listen indefinitely.
+
+        Returns:
+            Callable[[Callable[P, R]], Callable[P, R]] | Self: A decorator that registers the function as an event listener or the current instance of Env.
+        """
+        if isinstance(event, Event):
+            event = event.collapse()
+        if func is None:
+            return self._ee.on(event, ttl=ttl)
+        self._ee.on(event, func, ttl=ttl)
+        return self
+
+    @overload
+    def once[**P, R](
+        self,
+        event: str | Event,
+    ) -> Callable[[Callable[P, R]], Callable[P, R]]:
+        """
+        Registers an event listener that listens only once.
+
+        Args:
+            event (str | Event): The event to listen for.
+
+        Returns:
+            Callable[[Callable[P, R]], Callable[P, R]]: A decorator that registers the function as an event listener.
+        """
+        ...
+
+    @overload
+    def once[**P, R](
+        self,
+        event: str | Event,
+        func: Callable[[Callable[P, R]], Callable[P, R]],
+    ) -> Self:
+        """
+        Registers an event listener with a specific function that listens only once.
+
+        Args:
+            event (str | Event): The event to listen for.
+            func (Callable[P, R]): The function to be called when the event is emitted.
+
+        Returns:
+            Self: The current instance of Env.
+        """
+        ...
+
+    def once[**P, R](
+        self,
+        event: str | Event,
+        func: Optional[Callable[P, R]] = None,
+    ) -> Callable[[Callable[P, R]], Callable[P, R]] | Self:
+        """Registers an event listener with a specific function that listens only once.
+
+        Args:
+            event (str | Event): The event to listen for.
+            func (Callable[P, R]): The function to be called when the event is emitted.
+
+        Returns:
+            Callable[[Callable[P, R]], Callable[P, R]] | Self: A decorator that registers the function as an event listener or the current instance
+        """
+        if isinstance(event, Event):
+            event = event.collapse()
+        if func is None:
+            return self._ee.once(event)
+
+        self._ee.once(event, func)
+        return self
+
+    def emit[**P](self, event: str | Event, *args: P.args, **kwargs: P.kwargs) -> None:
+        """Emits an event to all registered listeners.
+
+        Args:
+            event (str | Event): The event to emit.
+            *args: Positional arguments to pass to the listeners.
+            **kwargs: Keyword arguments to pass to the listeners.
+        """
+        if isinstance(event, Event):
+            event = event.collapse()
+
+        self._ee.emit(event, *args, **kwargs)
+
+    async def emit_async[**P](self, event: str | Event, *args: P.args, **kwargs: P.kwargs) -> None:
+        """Asynchronously emits an event to all registered listeners.
+
+        Args:
+            event (str | Event): The event to emit.
+            *args: Positional arguments to pass to the listeners.
+            **kwargs: Keyword arguments to pass to the listeners.
+        """
+        if isinstance(event, Event):
+            event = event.collapse()
+        return await self._ee.emit_async(event, *args, **kwargs)
+
+    def emit_future[**P](self, event: str | Event, *args: P.args, **kwargs: P.kwargs) -> None:
+        """Emits an event to all registered listeners and returns a future object.
+
+        Args:
+            event (str | Event): The event to emit.
+            *args: Positional arguments to pass to the listeners.
+            **kwargs: Keyword arguments to pass to the listeners.
+
+        Returns:
+            None: The future object.
+        """
+        if isinstance(event, Event):
+            event = event.collapse()
+        return self._ee.emit_future(event, *args, **kwargs)
+
+
+env = Env()

fabricatio/decorators.py

@@ -0,0 +1,179 @@
+"""Decorators for Fabricatio."""
+
+from asyncio import iscoroutinefunction
+from functools import wraps
+from inspect import signature
+from shutil import which
+from types import ModuleType
+from typing import Callable, List, Optional
+
+from questionary import confirm
+
+from fabricatio.config import configs
+from fabricatio.journal import logger
+
+
+def depend_on_external_cmd[**P, R](
+    bin_name: str, install_tip: Optional[str], homepage: Optional[str] = None
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    """Decorator to check for the presence of an external command.
+
+    Args:
+        bin_name (str): The name of the required binary.
+        install_tip (Optional[str]): Installation instructions for the required binary.
+        homepage (Optional[str]): The homepage of the required binary.
+
+    Returns:
+        Callable[[Callable[P, R]], Callable[P, R]]: A decorator that wraps the function to check for the binary.
+
+    Raises:
+        RuntimeError: If the required binary is not found.
+    """
+
+    def _decorator(func: Callable[P, R]) -> Callable[P, R]:
+        @wraps(func)
+        def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            if which(bin_name) is None:
+                err = f"`{bin_name}` is required to run {func.__name__}{signature(func)}, please install it the to `PATH` first."
+                if install_tip is not None:
+                    err += f"\nInstall tip: {install_tip}"
+                if homepage is not None:
+                    err += f"\nHomepage: {homepage}"
+                logger.error(err)
+                raise RuntimeError(err)
+            return func(*args, **kwargs)
+
+        return _wrapper
+
+    return _decorator
+
+
+def logging_execution_info[**P, R](func: Callable[P, R]) -> Callable[P, R]:
+    """Decorator to log the execution of a function.
+
+    Args:
+        func (Callable): The function to be executed
+
+    Returns:
+        Callable: A decorator that wraps the function to log the execution.
+    """
+
+    @wraps(func)
+    def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        logger.info(f"Executing function: {func.__name__}{signature(func)}")
+        logger.debug(f"{func.__name__}{signature(func)}\nArgs: {args}\nKwargs: {kwargs}")
+        return func(*args, **kwargs)
+
+    return _wrapper
+
+
+def confirm_to_execute[**P, R](func: Callable[P, R]) -> Callable[P, Optional[R]] | Callable[P, R]:
+    """Decorator to confirm before executing a function.
+
+    Args:
+        func (Callable): The function to be executed
+
+    Returns:
+        Callable: A decorator that wraps the function to confirm before execution.
+    """
+    if not configs.general.confirm_on_ops:
+        # Skip confirmation if the configuration is set to False
+        return func
+
+    if iscoroutinefunction(func):
+
+        @wraps(func)
+        async def _wrapper(*args: P.args, **kwargs: P.kwargs) -> Optional[R]:
+            if await confirm(
+                f"Are you sure to execute function: {func.__name__}{signature(func)} \n📦 Args:{args}\n🔑 Kwargs:{kwargs}\n",
+                instruction="Please input [Yes/No] to proceed (default: Yes):",
+            ).ask_async():
+                return await func(*args, **kwargs)
+            logger.warning(f"Function: {func.__name__}{signature(func)} canceled by user.")
+            return None
+
+    else:
+
+        @wraps(func)
+        def _wrapper(*args: P.args, **kwargs: P.kwargs) -> Optional[R]:
+            if confirm(
+                f"Are you sure to execute function: {func.__name__}{signature(func)} \n📦 Args:{args}\n��� Kwargs:{kwargs}\n",
+                instruction="Please input [Yes/No] to proceed (default: Yes):",
+            ).ask():
+                return func(*args, **kwargs)
+            logger.warning(f"Function: {func.__name__}{signature(func)} canceled by user.")
+            return None
+
+    return _wrapper
+
+
+def use_temp_module[**P, R](modules: ModuleType | List[ModuleType]) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    """Temporarily inject modules into sys.modules during function execution.
+
+    This decorator allows you to temporarily inject one or more modules into sys.modules
+    while the decorated function executes. After execution, it restores the original
+    state of sys.modules.
+
+    Args:
+        modules (ModuleType | List[ModuleType]): A single module or list of modules to
+            temporarily inject into sys.modules.
+
+    Returns:
+        Callable[[Callable[P, R]], Callable[P, R]]: A decorator that handles temporary
+            module injection.
+
+    Examples:
+        ```python
+        from types import ModuleSpec, ModuleType, module_from_spec
+
+        # Create a temporary module
+        temp_module = module_from_spec(ModuleSpec("temp_math", None))
+        temp_module.pi = 3.14
+
+        # Use the decorator to temporarily inject the module
+        @use_temp_module(temp_module)
+        def calculate_area(radius: float) -> float:
+            from temp_math import pi
+            return pi * radius ** 2
+
+        # The temp_module is only available inside the function
+        result = calculate_area(5.0)  # Uses temp_module.pi
+        ```
+
+        Multiple modules can also be injected:
+        ```python
+        module1 = module_from_spec(ModuleSpec("mod1", None))
+        module2 = module_from_spec(ModuleSpec("mod2", None))
+
+        @use_temp_module([module1, module2])
+        def process_data():
+            import mod1, mod2
+            # Work with temporary modules
+            ...
+        ```
+    """
+    module_list = [modules] if isinstance(modules, ModuleType) else modules
+
+    def _decorator(func: Callable[P, R]) -> Callable[P, R]:
+        @wraps(func)
+        def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            import sys
+
+            # Store original modules if they exist
+            for module in module_list:
+                if module.__name__ in sys.modules:
+                    raise RuntimeError(
+                        f"Module '{module.__name__}' is already present in sys.modules and cannot be overridden."
+                    )
+                sys.modules[module.__name__] = module
+
+            try:
+                return func(*args, **kwargs)
+            finally:
+                # Restore original state
+                for module in module_list:
+                    del sys.modules[module.__name__]
+
+        return _wrapper
+
+    return _decorator

fabricatio/fs/__init__.py

@@ -0,0 +1,29 @@
+"""FileSystem manipulation module for Fabricatio."""
+
+from fabricatio.fs.curd import (
+    absolute_path,
+    copy_file,
+    create_directory,
+    delete_directory,
+    delete_file,
+    dump_text,
+    gather_files,
+    move_file,
+    tree,
+)
+from fabricatio.fs.readers import MAGIKA, safe_json_read, safe_text_read
+
+__all__ = [
+    "MAGIKA",
+    "absolute_path",
+    "copy_file",
+    "create_directory",
+    "delete_directory",
+    "delete_file",
+    "dump_text",
+    "gather_files",
+    "move_file",
+    "safe_json_read",
+    "safe_text_read",
+    "tree",
+]

fabricatio/fs/curd.py

@@ -0,0 +1,149 @@
+"""File system create, update, read, delete operations."""
+
+import shutil
+import subprocess
+from os import PathLike
+from pathlib import Path
+from typing import Union
+
+from fabricatio.decorators import depend_on_external_cmd
+from fabricatio.journal import logger
+
+
+def dump_text(path: Union[str, Path], text: str) -> None:
+    """Dump text to a file. you need to make sure the file's parent directory exists.
+
+    Args:
+        path(str, Path): Path to the file
+        text(str): Text to write to the file
+
+    Returns:
+        None
+    """
+    Path(path).write_text(text, encoding="utf-8", errors="ignore")
+
+
+def copy_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
+    """Copy a file from source to destination.
+
+    Args:
+        src: Source file path
+        dst: Destination file path
+
+    Raises:
+        FileNotFoundError: If source file doesn't exist
+        shutil.SameFileError: If source and destination are the same
+    """
+    try:
+        shutil.copy(src, dst)
+        logger.info(f"Copied file from {src} to {dst}")
+    except OSError as e:
+        logger.error(f"Failed to copy file from {src} to {dst}: {e!s}")
+        raise
+
+
+def move_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
+    """Move a file from source to destination.
+
+    Args:
+        src: Source file path
+        dst: Destination file path
+
+    Raises:
+        FileNotFoundError: If source file doesn't exist
+        shutil.SameFileError: If source and destination are the same
+    """
+    try:
+        shutil.move(src, dst)
+        logger.info(f"Moved file from {src} to {dst}")
+    except OSError as e:
+        logger.error(f"Failed to move file from {src} to {dst}: {e!s}")
+        raise
+
+
+def delete_file(file_path: Union[str, Path]) -> None:
+    """Delete a file.
+
+    Args:
+        file_path: Path to the file to be deleted
+
+    Raises:
+        FileNotFoundError: If file doesn't exist
+        PermissionError: If no permission to delete the file
+    """
+    try:
+        Path(file_path).unlink()
+        logger.info(f"Deleted file: {file_path}")
+    except OSError as e:
+        logger.error(f"Failed to delete file {file_path}: {e!s}")
+        raise
+
+
+def create_directory(dir_path: Union[str, Path], parents: bool = True, exist_ok: bool = True) -> None:
+    """Create a directory.
+
+    Args:
+        dir_path: Path to the directory to create
+        parents: Create parent directories if they don't exist
+        exist_ok: Don't raise error if directory already exists
+    """
+    try:
+        Path(dir_path).mkdir(parents=parents, exist_ok=exist_ok)
+        logger.info(f"Created directory: {dir_path}")
+    except OSError as e:
+        logger.error(f"Failed to create directory {dir_path}: {e!s}")
+        raise
+
+
+@depend_on_external_cmd(
+    "erd",
+    "Please install `erd` using `cargo install erdtree` or `scoop install erdtree`.",
+    "https://github.com/solidiquis/erdtree",
+)
+def tree(dir_path: Union[str, Path]) -> str:
+    """Generate a tree representation of the directory structure. Requires `erd` to be installed."""
+    dir_path = Path(dir_path)
+    return subprocess.check_output(("erd", dir_path.as_posix()), encoding="utf-8")  # noqa: S603
+
+
+def delete_directory(dir_path: Union[str, Path]) -> None:
+    """Delete a directory and its contents.
+
+    Args:
+        dir_path: Path to the directory to delete
+
+    Raises:
+        FileNotFoundError: If directory doesn't exist
+        OSError: If directory is not empty and can't be removed
+    """
+    try:
+        shutil.rmtree(dir_path)
+        logger.info(f"Deleted directory: {dir_path}")
+    except OSError as e:
+        logger.error(f"Failed to delete directory {dir_path}: {e!s}")
+        raise
+
+
+def absolute_path(path: str | Path | PathLike) -> str:
+    """Get the absolute path of a file or directory.
+
+    Args:
+        path (str, Path, PathLike): The path to the file or directory.
+
+    Returns:
+        str: The absolute path of the file or directory.
+    """
+    return Path(path).expanduser().resolve().as_posix()
+
+
+def gather_files(directory: str | Path | PathLike, extension: str) -> list[str]:
+    """Gather all files with a specific extension in a directory.
+
+    Args:
+        directory (str, Path, PathLike): The directory to search in.
+        extension (str): The file extension to look for.
+
+    Returns:
+        list[str]: A list of file paths with the specified extension.
+    """
+    return [file.as_posix() for file in Path(directory).rglob(f"*.{extension}")]

fabricatio/fs/readers.py

@@ -0,0 +1,46 @@
+"""Filesystem readers for Fabricatio."""
+
+from pathlib import Path
+from typing import Dict
+
+import orjson
+from magika import Magika
+
+from fabricatio.config import configs
+from fabricatio.journal import logger
+
+MAGIKA = Magika(model_dir=configs.magika.model_dir)
+
+
+def safe_text_read(path: Path | str) -> str:
+    """Safely read the text from a file.
+
+    Args:
+        path (Path|str): The path to the file.
+
+    Returns:
+        str: The text from the file.
+    """
+    path = Path(path)
+    try:
+        return path.read_text(encoding="utf-8")
+    except (UnicodeDecodeError, IsADirectoryError, FileNotFoundError) as e:
+        logger.error(f"Failed to read file {path}: {e!s}")
+        return ""
+
+
+def safe_json_read(path: Path | str) -> Dict:
+    """Safely read the JSON from a file.
+
+    Args:
+        path (Path|str): The path to the file.
+
+    Returns:
+        dict: The JSON from the file.
+    """
+    path = Path(path)
+    try:
+        return orjson.loads(path.read_text(encoding="utf-8"))
+    except (orjson.JSONDecodeError, IsADirectoryError, FileNotFoundError) as e:
+        logger.error(f"Failed to read file {path}: {e!s}")
+        return {}

fabricatio/journal.py

@@ -0,0 +1,21 @@
+"""Logging setup for the project."""
+
+import sys
+
+from loguru import logger
+from rich import pretty, traceback
+
+from fabricatio.config import configs
+
+pretty.install()
+traceback.install()
+logger.remove()
+logger.add(
+    configs.debug.log_file,
+    level=configs.debug.log_level,
+    rotation=f"{configs.debug.rotation} weeks",
+    retention=f"{configs.debug.retention} weeks",
+)
+logger.add(sys.stderr, level=configs.debug.log_level)
+
+__all__ = ["logger"]