bear-utils 0.7.11__py3-none-any.whl

bear_utils/files/file_handlers/file_handler_factory.py

@@ -0,0 +1,278 @@
+import warnings
+from pathlib import Path
+from typing import Any, cast
+
+from ._base_file_handler import FileHandler
+
+
+class FileHandlerFactory:
+    """Factory class to create and manage FileHandler instances based on file types.
+
+    This factory maintains state about the current file path and can create appropriate
+    handlers for different file types.
+    """
+
+    def __init__(self, file_path: Path | None = None) -> None:
+        """Initialize the factory with an optional file path.
+
+        Args:
+            file_path: Optional Path to the file to handle
+        """
+        self._file_path: Path | None = file_path
+        self._handler_registry: dict[str, type[FileHandler]] = {}
+        self._handler_instance: FileHandler | None = None
+        self._register_default_handlers()
+
+    @property
+    def file_path(self) -> Path | None:
+        """Get the current file path."""
+        return self._file_path
+
+    @file_path.setter
+    def file_path(self, path: Path) -> None:
+        """Set the current file path and reset the handler instance.
+
+        Args:
+            path: New file path to set
+        """
+        self._file_path = path
+        self._handler_instance = None
+
+    def _register_default_handlers(self) -> None:
+        """Register all default handlers from the package.
+
+        This method imports and registers all standard FileHandler implementations.
+        """
+        try:
+            from .json_file_handler import JsonFileHandler
+            from .log_file_handler import LogFileHandler
+            from .txt_file_handler import TextFileHandler
+            from .yaml_file_handler import YamlFileHandler
+
+            self.register_handler(JsonFileHandler)
+            self.register_handler(TextFileHandler)
+            self.register_handler(YamlFileHandler)
+            self.register_handler(LogFileHandler)
+
+        except ImportError as e:
+            warnings.warn(f"Could not import all default handlers: {e}")
+
+    def register_handler(self, handler_class: type[FileHandler]) -> None:
+        """Register a handler class for its supported extensions.
+
+        Args:
+            handler_class: The FileHandler class to register
+        """
+        for ext in handler_class.valid_extensions:
+            self._handler_registry[ext] = handler_class
+
+    def get_handler_class(self, extension: str) -> type[FileHandler] | None:
+        """Get the handler class for a specific extension.
+
+        Args:
+            extension: File extension (without the dot)
+
+        Returns:
+            FileHandler class for the extension or None if not found
+        """
+        return self._handler_registry.get(extension)
+
+    def get_handler_for_path(self, file_path: Path | None = None) -> FileHandler:
+        """Get or create a handler instance for the given path or the current path.
+
+        Args:
+            file_path: Path to get handler for (uses stored path if None)
+
+        Returns:
+            Appropriate FileHandler instance
+
+        Raises:
+            ValueError: If no file path is provided or stored, or if no handler exists for the file extension
+        """
+        path = file_path or self._file_path
+        if not path:
+            raise ValueError("No file path provided or stored in factory")
+
+        if file_path:
+            self._file_path = file_path
+            self._handler_instance = None
+
+        if self._handler_instance and not file_path:
+            return self._handler_instance
+
+        extension = path.suffix.lstrip(".")
+        handler_class = self.get_handler_class(extension)
+
+        if not handler_class:
+            raise ValueError(f"No handler registered for extension: {extension}")
+
+        handler = handler_class()
+        if not file_path:  # Only cache if using the stored path
+            self._handler_instance = handler
+
+        return handler
+
+    def handle_file(self, operation: str, file_path: Path | None = None, data: Any = None, **kwargs) -> Any:
+        """Handle file operations using the appropriate handler.
+
+        Args:
+            operation: Operation to perform ('read', 'write', 'present', 'info')
+            file_path: Path to the file (uses stored path if None)
+            data: Data for write operations
+            **kwargs: Additional arguments for the operation
+
+        Returns:
+            Result of the operation
+
+        Raises:
+            ValueError: If an invalid operation is specified
+        """
+        path: Path | None = file_path or self._file_path
+        if not path and operation != "present":
+            raise ValueError("File path required for this operation")
+
+        match operation:
+            case "read":
+                handler = self.get_handler_for_path(path)
+                return handler.read_file(cast(Path, path), **kwargs)
+            case "write":
+                if data is None:
+                    raise ValueError("Data required for write operation")
+                handler = self.get_handler_for_path(path)
+                return handler.write_file(cast(Path, path), data, **kwargs)
+            case "present":
+                if data is None:
+                    raise ValueError("Data required for present operation")
+                if path:
+                    handler: FileHandler = self.get_handler_for_path(path)
+                else:
+                    if isinstance(data, dict):
+                        yaml_class = self.get_handler_class("yaml")
+                        if yaml_class:
+                            handler = yaml_class()
+                        else:
+                            raise ValueError("No handler available for dict data")
+                    elif isinstance(data, str):
+                        text_class = self.get_handler_class("txt")
+                        if text_class:
+                            handler = text_class()
+                        else:
+                            raise ValueError("No handler available for string data")
+                    else:
+                        raise ValueError(f"Cannot determine handler for data type: {type(data)}")
+                return handler.present_file(data)
+
+            case "info":
+                handler = self.get_handler_for_path(path)
+                return handler.get_file_info(cast(Path, path))
+            case _:
+                raise ValueError(f"Invalid operation: {operation}")
+
+    def read(self, file_path: Path | None = None, **kwargs) -> Any:
+        """Read a file using the appropriate handler.
+
+        Args:
+            file_path: Path to read (uses stored path if None)
+            **kwargs: Additional arguments for read_file
+
+        Returns:
+            File contents
+        """
+        return self.handle_file("read", file_path, **kwargs)
+
+    def write(self, data: dict | str, file_path: Path | None = None, **kwargs) -> None:
+        """Write to a file using the appropriate handler.
+
+        Args:
+            data: Data to write
+            file_path: Path to write to (uses stored path if None)
+            **kwargs: Additional arguments for write_file
+        """
+        return self.handle_file("write", file_path, data, **kwargs)
+
+    def present(self, data: dict | str, file_path: Path | None = None) -> str:
+        """Present data using the appropriate handler.
+
+        Args:
+            data: Data to present
+            file_path: Optional path to determine format (uses stored path if None)
+
+        Returns:
+            String representation of the data
+        """
+        return self.handle_file("present", file_path, data)
+
+    def get_info(self, file_path: Path | None = None) -> dict[str, Any]:
+        """Get information about a file.
+
+        Args:
+            file_path: Path to get info for (uses stored path if None)
+
+        Returns:
+            Dictionary with file information
+        """
+        return self.handle_file("info", file_path)
+
+    def convert(self, source_path: Path, target_path: Path, **kwargs) -> None:
+        """Convert a file from one format to another.
+
+        Args:
+            source_path: Path to the source file
+            target_path: Path to the target file
+            **kwargs: Additional arguments for read_file and write_file
+        """
+        source_handler = self.get_handler_for_path(source_path)
+        data = source_handler.read_file(source_path, **kwargs)
+
+        target_handler = self.get_handler_for_path(target_path)
+        target_handler.write_file(target_path, data, **kwargs)
+
+
+_default_factory = FileHandlerFactory()
+
+
+def get_handler_for_file(file_path: Path) -> FileHandler:
+    """Get a handler for the given file path.
+
+    Args:
+        file_path: Path to the file
+
+    Returns:
+        Appropriate FileHandler instance
+    """
+    return _default_factory.get_handler_for_path(file_path)
+
+
+def read_file(file_path: Path, **kwargs) -> Any:
+    """Read a file using the appropriate handler.
+
+    Args:
+        file_path: Path to the file
+        **kwargs: Additional arguments for read_file
+
+    Returns:
+        File contents
+    """
+    return _default_factory.read(file_path, **kwargs)
+
+
+def write_file(file_path: Path, data: Any, **kwargs) -> None:
+    """Write to a file using the appropriate handler.
+
+    Args:
+        file_path: Path to the file
+        data: Data to write
+        **kwargs: Additional arguments for write_file
+    """
+    return _default_factory.write(data, file_path, **kwargs)
+
+
+def convert_file(source_path: Path, target_path: Path, **kwargs) -> None:
+    """Convert a file from one format to another.
+
+    Args:
+        source_path: Path to the source file
+        target_path: Path to the target file
+        **kwargs: Additional arguments for read_file and write_file
+    """
+    return _default_factory.convert(source_path, target_path, **kwargs)

bear_utils/files/file_handlers/json_file_handler.py

@@ -0,0 +1,44 @@
+import json
+from pathlib import Path
+from typing import Any, ClassVar
+
+from ._base_file_handler import FileHandler
+
+
+class JsonFileHandler(FileHandler):
+    """Class for handling JSON files with read, write, and present methods"""
+
+    valid_extensions: ClassVar[list[str]] = ["json"]
+
+    @FileHandler.ValidateFileType
+    def read_file(self, file_path: Path, **kwargs) -> dict[str, Any]:
+        try:
+            super().read_file(file_path)
+            with open(file_path, "r", encoding="utf-8") as file:
+                return json.load(file, **kwargs)
+        except Exception as e:
+            raise ValueError(f"Error reading file: {e}")
+
+    @FileHandler.ValidateFileType
+    def write_file(self, file_path: Path, data: dict[str, Any] | str, **kwargs) -> None:
+        try:
+            super().write_file(file_path, data)
+            with open(file_path, "w", encoding="utf-8") as file:
+                json.dump(
+                    data,
+                    file,
+                    indent=kwargs.pop("indent", 4),
+                    **kwargs,
+                )
+        except Exception as e:
+            raise ValueError(f"Error writing file: {e}")
+
+    def present_file(self, data: dict[str, Any] | str, **kwargs) -> str:
+        try:
+            return json.dumps(
+                data,
+                indent=kwargs.pop("indent", 4),
+                **kwargs,
+            )
+        except Exception as e:
+            raise ValueError(f"Error presenting file: {e}")

bear_utils/files/file_handlers/log_file_handler.py

@@ -0,0 +1,33 @@
+from pathlib import Path
+from typing import Any, ClassVar
+
+from ._base_file_handler import FileHandler
+
+
+class LogFileHandler(FileHandler):
+    """Class for handling .log files with read, write, and present methods"""
+
+    valid_extensions: ClassVar[list[str]] = ["log"]
+
+    @FileHandler.ValidateFileType
+    def read_file(self, file_path: Path) -> str:
+        try:
+            super().read_file(file_path)
+            with open(file_path, "r", encoding="utf-8") as file:
+                return file.read()
+        except Exception as e:
+            raise ValueError(f"Error reading file: {e}")
+
+    @FileHandler.ValidateFileType
+    def write_file(self, file_path: Path, data: dict[str, Any] | str, **kwargs) -> None:
+        try:
+            super().write_file(file_path, data)
+            if not isinstance(data, str):
+                raise ValueError("Data must be a string for log files")
+            with open(file_path, "w", encoding="utf-8") as file:
+                file.write(data)
+        except Exception as e:
+            raise ValueError(f"Error writing file: {e}")
+
+    def present_file(self, data: dict[str, Any] | str, **kwargs) -> str:
+        raise NotImplementedError("Presenting log files is not implemented. Not needed.")

bear_utils/files/file_handlers/txt_file_handler.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+from typing import Any, ClassVar
+
+from ._base_file_handler import FileHandler
+
+
+class TextFileHandler(FileHandler):
+    """Class for handling .txt files with read, write, and present methods"""
+
+    valid_extensions: ClassVar[list[str]] = ["txt"]
+
+    @FileHandler.ValidateFileType
+    def read_file(self, file_path: Path) -> str:
+        try:
+            super().read_file(file_path)
+            with open(file_path, "r", encoding="utf-8") as file:
+                return file.read()
+        except Exception as e:
+            raise ValueError(f"Error reading file: {e}")
+
+    @FileHandler.ValidateFileType
+    def write_file(self, file_path: Path, data: dict[str, Any] | str, **kwargs) -> None:
+        try:
+            super().write_file(file_path, data)
+            if not isinstance(data, str):
+                raise ValueError("Data must be a string for text files")
+
+            with open(file_path, "w", encoding="utf-8") as file:
+                file.write(data)
+        except Exception as e:
+            raise ValueError(f"Error writing file: {e}")
+
+    def present_file(self, data: dict[str, Any] | str, **kwargs) -> str:
+        raise NotImplementedError("Presenting text files is not implemented. Not needed.")

bear_utils/files/file_handlers/yaml_file_handler.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+from typing import Any, ClassVar
+
+import yaml
+
+from ._base_file_handler import FileHandler
+
+
+class YamlFileHandler(FileHandler):
+    """Class for handling .yaml/.yml files with read, write, and present methods"""
+
+    valid_extensions: ClassVar[list[str]] = ["yaml", "yml"]
+
+    @FileHandler.ValidateFileType
+    def unsafe_read_file(self, file_path: Path, **kwargs) -> dict[str, Any]:
+        """Read YAML file with potentially unsafe loader.
+
+        WARNING: This method can execute arbitrary code and should only be used
+        with trusted files.
+
+        Args:
+            file_path: Path to the YAML file
+            **kwargs: Additional arguments passed to yaml.load
+
+        Returns:
+            Dictionary containing the parsed YAML data
+        """
+        try:
+            super().read_file(file_path)
+            with open(file_path, "r", encoding="utf-8") as file:
+                return yaml.load(file, **kwargs)
+        except Exception as e:
+            raise ValueError(f"Error reading file: {e}")
+
+    @FileHandler.ValidateFileType
+    def read_file(self, file_path: Path) -> dict[str, Any]:
+        try:
+            super().read_file(file_path)
+            with open(file_path, "r", encoding="utf-8") as file:
+                return yaml.safe_load(file)
+        except Exception as e:
+            raise ValueError(f"Error reading file: {e}")
+
+    @FileHandler.ValidateFileType
+    def write_file(self, file_path: Path, data: dict[str, Any] | str, **kwargs) -> None:
+        try:
+            super().write_file(file_path, data)
+            with open(file_path, "w", encoding="utf-8") as file:
+                yaml.dump(data, file, default_flow_style=False, sort_keys=False, **kwargs)
+        except Exception as e:
+            raise ValueError(f"Error writing file: {e}")
+
+    def present_file(self, data: dict[str, Any] | str, **kwargs) -> str:
+        try:
+            return yaml.dump(data, default_flow_style=False, sort_keys=False, **kwargs)
+        except Exception as e:
+            raise ValueError(f"Error presenting file: {e}")