fabricatio 0.3.15.dev5__cp312-cp312-win_amd64.whl → 0.4.4__cp312-cp312-win_amd64.whl

fabricatio/decorators.py

@@ -1,253 +0,0 @@
-"""Decorators for Fabricatio."""
-
-from asyncio import iscoroutinefunction
-from functools import wraps
-from importlib.util import find_spec
-from inspect import signature
-from shutil import which
-from types import ModuleType
-from typing import Callable, Coroutine, List, Optional
-
-from fabricatio.journal import logger
-from fabricatio.rust import CONFIG
-
-
-def precheck_package[**P, R](package_name: str, msg: str) -> Callable[[Callable[P, R]], Callable[P, R]]:
-    """Check if a package exists in the current environment.
-
-    Args:
-        package_name (str): The name of the package to check.
-        msg (str): The message to display if the package is not found.
-
-    Returns:
-        bool: True if the package exists, False otherwise.
-    """
-
-    def _wrapper(
-        func: Callable[P, R] | Callable[P, Coroutine[None, None, R]],
-    ) -> Callable[P, R] | Callable[P, Coroutine[None, None, R]]:
-        if iscoroutinefunction(func):
-
-            @wraps(func)
-            async def _async_inner(*args: P.args, **kwargs: P.kwargs) -> R:
-                if find_spec(package_name):
-                    return await func(*args, **kwargs)
-                raise RuntimeError(msg)
-
-            return _async_inner
-
-        @wraps(func)
-        def _inner(*args: P.args, **kwargs: P.kwargs) -> R:
-            if find_spec(package_name):
-                return func(*args, **kwargs)
-            raise RuntimeError(msg)
-
-        return _inner
-
-    return _wrapper
-
-
-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
-
-
-@precheck_package(
-    "questionary", "'questionary' is required to run this function. Have you installed `fabricatio[qa]`?."
-)
-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 CONFIG.general.confirm_on_ops:
-        # Skip confirmation if the configuration is set to False
-        return func
-    from questionary import confirm
-
-    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
-
-
-def logging_exec_time[**P, R](
-    func: Callable[P, R] | Callable[P, Coroutine[None, None, R]],
-) -> Callable[P, R] | Callable[P, Coroutine[None, None, R]]:
-    """Decorator to log the execution time of a function.
-
-    Args:
-        func (Callable): The function to be executed
-
-    Returns:
-        Callable: A decorator that wraps the function to log the execution time.
-    """
-    from time import time
-
-    if iscoroutinefunction(func):
-
-        @wraps(func)
-        async def _async_wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
-            start_time = time()
-            logger.debug(f"Starting execution of {func.__name__}")
-            result = await func(*args, **kwargs)
-            logger.debug(f"Execution time of `{func.__name__}`: {time() - start_time:.2f} s")
-            return result
-
-        return _async_wrapper
-
-    @wraps(func)
-    def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
-        start_time = time()
-        logger.debug(f"Starting execution of {func.__name__}")
-        result = func(*args, **kwargs)
-        logger.debug(f"Execution time of {func.__name__}: {(time() - start_time) * 1000:.2f} ms")
-        return result
-
-    return _wrapper

fabricatio/emitter.py

@@ -1,177 +0,0 @@
-"""Core module that contains the Env class for managing event handling."""
-from dataclasses import dataclass
-from typing import Callable, ClassVar, Optional, Self, overload
-
-from pymitter import EventEmitter
-
-from fabricatio.rust import CONFIG, Event
-
-
-@dataclass
-class Env:
-    """Environment class that manages event handling using EventEmitter."""
-
-    ee: ClassVar[EventEmitter] = EventEmitter(
-        delimiter=CONFIG.pymitter.delimiter,
-        new_listener=CONFIG.pymitter.new_listener_event,
-        max_listeners=CONFIG.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/fs/__init__.py

@@ -1,35 +0,0 @@
-"""FileSystem manipulation module for Fabricatio."""
-from importlib.util import find_spec
-
-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 safe_json_read, safe_text_read
-
-__all__ = [
-    "absolute_path",
-    "copy_file",
-    "create_directory",
-    "delete_directory",
-    "delete_file",
-    "dump_text",
-    "gather_files",
-    "move_file",
-    "safe_json_read",
-    "safe_text_read",
-    "tree",
-]
-
-if find_spec("magika"):
-    from magika import Magika
-
-    MAGIKA = Magika()
-    __all__ += ["MAGIKA"]

fabricatio/fs/curd.py

@@ -1,153 +0,0 @@
-"""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", newline="\n")
-
-
-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.
-
-    Example:
-        >>> gather_files('/path/to/directory', 'txt')
-        ['/path/to/directory/file1.txt', '/path/to/directory/file2.txt']
-    """
-    return [file.as_posix() for file in Path(directory).rglob(f"*.{extension}")]

fabricatio/fs/readers.py

@@ -1,61 +0,0 @@
-"""Filesystem readers for Fabricatio."""
-
-import re
-from pathlib import Path
-from typing import Dict, List, Tuple
-
-import ujson
-
-from fabricatio.journal import logger
-
-
-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 ujson.loads(path.read_text(encoding="utf-8"))
-    except (ujson.JSONDecodeError, IsADirectoryError, FileNotFoundError) as e:
-        logger.error(f"Failed to read file {path}: {e!s}")
-        return {}
-
-
-def extract_sections(string: str, level: int, section_char: str = "#") -> List[Tuple[str, str]]:
-    """Extract sections from markdown-style text by header level.
-
-    Args:
-        string (str): Input text to parse
-        level (int): Header level (e.g., 1 for '#', 2 for '##')
-        section_char (str, optional): The character used for headers (default: '#')
-
-    Returns:
-        List[Tuple[str, str]]: List of (header_text, section_content) tuples
-    """
-    return re.findall(
-        r"^%s{%d}\s+(.+?)\n((?:(?!^%s{%d}\s).|\n)*)" % (section_char, level, section_char, level),
-        string,
-        re.MULTILINE,
-    )

fabricatio/journal.py

@@ -1,12 +0,0 @@
-"""Logging setup for the project."""
-
-import sys
-
-from loguru import logger
-
-from fabricatio.rust import CONFIG
-
-logger.remove()
-logger.add(sys.stderr, level=CONFIG.debug.log_level)
-
-__all__ = ["logger"]