sortmeout 1.0.0__py3-none-any.whl

sortmeout/utils/file_info.py

@@ -0,0 +1,363 @@
+"""
+File information extraction.
+
+This module provides functions for extracting various attributes from files,
+including standard file system attributes and macOS-specific metadata.
+"""
+
+from __future__ import annotations
+
+import mimetypes
+import os
+import subprocess
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+def get_file_info(file_path: str) -> Dict[str, Any]:
+    """
+    Get comprehensive information about a file.
+
+    Args:
+        file_path: Path to the file.
+
+    Returns:
+        Dictionary containing file attributes.
+    """
+    path = Path(file_path)
+    stat = path.stat()
+
+    info = {
+        # Basic attributes
+        "path": str(path.absolute()),
+        "name": path.stem,
+        "extension": path.suffix.lstrip(".").lower(),
+        "full_name": path.name,
+        "parent_folder": path.parent.name,
+        "parent_path": str(path.parent),
+
+        # Size
+        "size": stat.st_size,
+        "size_bytes": stat.st_size,
+        "size_human": _format_size(stat.st_size),
+
+        # Dates
+        "date_created": datetime.fromtimestamp(stat.st_birthtime) if hasattr(stat, "st_birthtime") else datetime.fromtimestamp(stat.st_ctime),
+        "date_modified": datetime.fromtimestamp(stat.st_mtime),
+        "date_accessed": datetime.fromtimestamp(stat.st_atime),
+
+        # Type
+        "is_file": path.is_file(),
+        "is_directory": path.is_dir(),
+        "is_symlink": path.is_symlink(),
+        "is_hidden": path.name.startswith("."),
+    }
+
+    # MIME type
+    mime_type, _ = mimetypes.guess_type(str(path))
+    info["mime_type"] = mime_type
+    info["file_type"] = mime_type
+
+    # Determine kind based on extension/mime
+    info["kind"] = _get_file_kind(path.suffix, mime_type)
+
+    # macOS-specific attributes
+    try:
+        macos_info = _get_macos_metadata(file_path)
+        info.update(macos_info)
+    except Exception:
+        pass
+
+    return info
+
+
+def _format_size(size_bytes: int) -> str:
+    """Format size in bytes to human-readable string."""
+    for unit in ["B", "KB", "MB", "GB", "TB"]:
+        if size_bytes < 1024:
+            return f"{size_bytes:.1f} {unit}"
+        size_bytes /= 1024
+    return f"{size_bytes:.1f} PB"
+
+
+def _get_file_kind(extension: str, mime_type: Optional[str]) -> str:
+    """Determine the kind of file based on extension and MIME type."""
+    extension = extension.lower().lstrip(".")
+
+    # Extension-based kinds
+    kinds = {
+        # Documents
+        "pdf": "PDF Document",
+        "doc": "Word Document",
+        "docx": "Word Document",
+        "xls": "Excel Spreadsheet",
+        "xlsx": "Excel Spreadsheet",
+        "ppt": "PowerPoint Presentation",
+        "pptx": "PowerPoint Presentation",
+        "txt": "Plain Text",
+        "rtf": "Rich Text Document",
+        "md": "Markdown Document",
+        "pages": "Pages Document",
+        "numbers": "Numbers Spreadsheet",
+        "key": "Keynote Presentation",
+
+        # Images
+        "jpg": "JPEG Image",
+        "jpeg": "JPEG Image",
+        "png": "PNG Image",
+        "gif": "GIF Image",
+        "bmp": "BMP Image",
+        "tiff": "TIFF Image",
+        "tif": "TIFF Image",
+        "webp": "WebP Image",
+        "svg": "SVG Image",
+        "ico": "Icon",
+        "heic": "HEIC Image",
+        "heif": "HEIF Image",
+        "raw": "RAW Image",
+        "psd": "Photoshop Document",
+        "ai": "Illustrator Document",
+
+        # Audio
+        "mp3": "MP3 Audio",
+        "wav": "WAV Audio",
+        "aac": "AAC Audio",
+        "flac": "FLAC Audio",
+        "m4a": "M4A Audio",
+        "ogg": "OGG Audio",
+        "wma": "WMA Audio",
+        "aiff": "AIFF Audio",
+
+        # Video
+        "mp4": "MP4 Video",
+        "mov": "QuickTime Movie",
+        "avi": "AVI Video",
+        "mkv": "MKV Video",
+        "wmv": "WMV Video",
+        "flv": "FLV Video",
+        "webm": "WebM Video",
+        "m4v": "M4V Video",
+
+        # Archives
+        "zip": "ZIP Archive",
+        "rar": "RAR Archive",
+        "7z": "7-Zip Archive",
+        "tar": "TAR Archive",
+        "gz": "Gzip Archive",
+        "bz2": "Bzip2 Archive",
+        "dmg": "Disk Image",
+        "iso": "ISO Image",
+
+        # Code
+        "py": "Python Script",
+        "js": "JavaScript",
+        "ts": "TypeScript",
+        "html": "HTML Document",
+        "css": "CSS Stylesheet",
+        "json": "JSON File",
+        "xml": "XML File",
+        "yaml": "YAML File",
+        "yml": "YAML File",
+        "sh": "Shell Script",
+        "java": "Java Source",
+        "cpp": "C++ Source",
+        "c": "C Source",
+        "h": "Header File",
+        "swift": "Swift Source",
+        "rb": "Ruby Script",
+        "go": "Go Source",
+        "rs": "Rust Source",
+
+        # Applications
+        "app": "Application",
+        "exe": "Windows Executable",
+        "pkg": "Installer Package",
+
+        # Other
+        "torrent": "Torrent File",
+        "ics": "Calendar Event",
+        "vcf": "Contact Card",
+    }
+
+    if extension in kinds:
+        return kinds[extension]
+
+    # MIME-based fallback
+    if mime_type:
+        if mime_type.startswith("image/"):
+            return "Image"
+        elif mime_type.startswith("video/"):
+            return "Video"
+        elif mime_type.startswith("audio/"):
+            return "Audio"
+        elif mime_type.startswith("text/"):
+            return "Text Document"
+        elif mime_type.startswith("application/"):
+            return "Application"
+
+    return "Document"
+
+
+def _get_macos_metadata(file_path: str) -> Dict[str, Any]:
+    """
+    Get macOS-specific metadata using mdls command.
+
+    Args:
+        file_path: Path to the file.
+
+    Returns:
+        Dictionary of macOS metadata.
+    """
+    info = {}
+
+    try:
+        # Get Spotlight metadata
+        result = subprocess.run(
+            ["mdls", "-plist", "-", file_path],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+
+        if result.returncode == 0:
+            import plistlib
+            metadata = plistlib.loads(result.stdout.encode())
+
+            # Extract useful attributes
+            attr_mapping = {
+                "kMDItemWhereFroms": "where_from",
+                "kMDItemUserTags": "tags",
+                "kMDItemFinderComment": "finder_comment",
+                "kMDItemContentType": "uti",
+                "kMDItemKind": "kind_macos",
+                "kMDItemDateAdded": "date_added",
+                "kMDItemDownloadedDate": "date_downloaded",
+                "kMDItemPixelHeight": "pixel_height",
+                "kMDItemPixelWidth": "pixel_width",
+                "kMDItemDurationSeconds": "duration_seconds",
+                "kMDItemTitle": "title",
+                "kMDItemAuthors": "authors",
+                "kMDItemCreator": "creator",
+                "kMDItemDescription": "description",
+            }
+
+            for mdls_key, our_key in attr_mapping.items():
+                if mdls_key in metadata and metadata[mdls_key] is not None:
+                    value = metadata[mdls_key]
+                    # Handle lists
+                    if isinstance(value, list) and len(value) == 1:
+                        value = value[0]
+                    info[our_key] = value
+
+    except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+        pass
+    except Exception:
+        pass
+
+    # Get tags using xattr if not found via mdls
+    if "tags" not in info:
+        try:
+            tags = _get_finder_tags(file_path)
+            if tags:
+                info["tags"] = tags
+        except Exception:
+            pass
+
+    return info
+
+
+def _get_finder_tags(file_path: str) -> List[str]:
+    """
+    Get Finder tags from a file using xattr.
+
+    Args:
+        file_path: Path to the file.
+
+    Returns:
+        List of tag names.
+    """
+    try:
+        import plistlib
+
+        result = subprocess.run(
+            ["xattr", "-p", "com.apple.metadata:_kMDItemUserTags", file_path],
+            capture_output=True,
+            timeout=5,
+        )
+
+        if result.returncode == 0 and result.stdout:
+            # Parse the binary plist
+            tags_data = plistlib.loads(result.stdout)
+            return [tag.split("\n")[0] for tag in tags_data if tag]
+    except Exception:
+        pass
+
+    return []
+
+
+def get_file_contents(file_path: str, max_bytes: int = 1024 * 1024) -> Optional[str]:
+    """
+    Read file contents (for text files).
+
+    Args:
+        file_path: Path to the file.
+        max_bytes: Maximum bytes to read.
+
+    Returns:
+        File contents as string, or None if not readable.
+    """
+    try:
+        with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+            return f.read(max_bytes)
+    except Exception:
+        return None
+
+
+def get_download_source(file_path: str) -> Optional[str]:
+    """
+    Get the URL from which a file was downloaded.
+
+    Args:
+        file_path: Path to the file.
+
+    Returns:
+        Download URL or None.
+    """
+    info = _get_macos_metadata(file_path)
+    where_from = info.get("where_from")
+
+    if isinstance(where_from, list):
+        return where_from[0] if where_from else None
+    return where_from
+
+
+def is_complete_download(file_path: str) -> bool:
+    """
+    Check if a file is a complete download (not still being downloaded).
+
+    Args:
+        file_path: Path to the file.
+
+    Returns:
+        True if download is complete.
+    """
+    path = Path(file_path)
+
+    # Check for common incomplete download extensions
+    incomplete_extensions = {
+        ".crdownload",  # Chrome
+        ".part",  # Firefox, wget
+        ".download",  # Safari
+        ".tmp",
+        ".partial",
+    }
+
+    if path.suffix.lower() in incomplete_extensions:
+        return False
+
+    # Check for .download companion file (Safari)
+    if (path.parent / f"{path.name}.download").exists():
+        return False
+
+    return True

sortmeout/utils/logger.py

@@ -0,0 +1,214 @@
+"""
+Logging configuration for SortMeOut.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import sys
+from datetime import datetime
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+from typing import Optional
+
+import appdirs
+
+# Application name for directories
+APP_NAME = "SortMeOut"
+APP_AUTHOR = "SortMeOut"
+
+# Default log format
+DEFAULT_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+SIMPLE_FORMAT = "%(levelname)s: %(message)s"
+DETAILED_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s"
+
+
+def get_log_directory() -> Path:
+    """Get the log directory path."""
+    log_dir = Path(appdirs.user_log_dir(APP_NAME, APP_AUTHOR))
+    log_dir.mkdir(parents=True, exist_ok=True)
+    return log_dir
+
+
+def setup_logging(
+    level: int = logging.INFO,
+    log_file: Optional[str] = None,
+    console: bool = True,
+    file_logging: bool = True,
+    max_file_size: int = 10 * 1024 * 1024,  # 10 MB
+    backup_count: int = 5,
+    format_string: Optional[str] = None,
+) -> logging.Logger:
+    """
+    Set up logging for the application.
+
+    Args:
+        level: Logging level.
+        log_file: Path to log file. If None, uses default location.
+        console: Enable console logging.
+        file_logging: Enable file logging.
+        max_file_size: Maximum log file size before rotation.
+        backup_count: Number of backup files to keep.
+        format_string: Custom format string.
+
+    Returns:
+        Root logger instance.
+    """
+    # Get root logger for our package
+    root_logger = logging.getLogger("sortmeout")
+    root_logger.setLevel(level)
+
+    # Clear existing handlers
+    root_logger.handlers.clear()
+
+    # Determine format
+    if format_string is None:
+        format_string = DETAILED_FORMAT if level == logging.DEBUG else DEFAULT_FORMAT
+
+    formatter = logging.Formatter(format_string)
+
+    # Console handler
+    if console:
+        console_handler = logging.StreamHandler(sys.stdout)
+        console_handler.setLevel(level)
+        console_handler.setFormatter(logging.Formatter(SIMPLE_FORMAT))
+        root_logger.addHandler(console_handler)
+
+    # File handler
+    if file_logging:
+        if log_file is None:
+            log_dir = get_log_directory()
+            log_file = str(log_dir / "sortmeout.log")
+
+        file_handler = RotatingFileHandler(
+            log_file,
+            maxBytes=max_file_size,
+            backupCount=backup_count,
+        )
+        file_handler.setLevel(level)
+        file_handler.setFormatter(formatter)
+        root_logger.addHandler(file_handler)
+
+    return root_logger
+
+
+def get_logger(name: str) -> logging.Logger:
+    """
+    Get a logger for a module.
+
+    Args:
+        name: Logger name (usually __name__).
+
+    Returns:
+        Logger instance.
+    """
+    # Ensure name is under our package namespace
+    if not name.startswith("sortmeout"):
+        name = f"sortmeout.{name}"
+
+    return logging.getLogger(name)
+
+
+class ActionLogger:
+    """
+    Specialized logger for tracking file actions.
+
+    Logs actions to a separate file for easy auditing.
+    """
+
+    def __init__(self, log_file: Optional[str] = None):
+        """
+        Initialize action logger.
+
+        Args:
+            log_file: Path to action log file.
+        """
+        self.logger = logging.getLogger("sortmeout.actions")
+        self.logger.setLevel(logging.INFO)
+
+        if log_file is None:
+            log_dir = get_log_directory()
+            log_file = str(log_dir / "actions.log")
+
+        handler = RotatingFileHandler(
+            log_file,
+            maxBytes=10 * 1024 * 1024,
+            backupCount=10,
+        )
+        handler.setFormatter(logging.Formatter(
+            "%(asctime)s | %(message)s"
+        ))
+        self.logger.addHandler(handler)
+
+    def log_action(
+        self,
+        action_type: str,
+        source: str,
+        destination: Optional[str] = None,
+        success: bool = True,
+        details: Optional[str] = None,
+    ) -> None:
+        """
+        Log a file action.
+
+        Args:
+            action_type: Type of action performed.
+            source: Source file path.
+            destination: Destination path (if applicable).
+            success: Whether action succeeded.
+            details: Additional details.
+        """
+        status = "SUCCESS" if success else "FAILED"
+
+        message_parts = [
+            status,
+            action_type.upper(),
+            f"src={source}",
+        ]
+
+        if destination:
+            message_parts.append(f"dst={destination}")
+
+        if details:
+            message_parts.append(f"({details})")
+
+        message = " | ".join(message_parts)
+
+        if success:
+            self.logger.info(message)
+        else:
+            self.logger.error(message)
+
+    def get_recent_actions(self, count: int = 100) -> list:
+        """
+        Get recent logged actions.
+
+        Args:
+            count: Number of recent actions to retrieve.
+
+        Returns:
+            List of action log entries.
+        """
+        log_dir = get_log_directory()
+        log_file = log_dir / "actions.log"
+
+        if not log_file.exists():
+            return []
+
+        with open(log_file, "r") as f:
+            lines = f.readlines()
+
+        return lines[-count:]
+
+
+# Global action logger instance
+_action_logger: Optional[ActionLogger] = None
+
+
+def get_action_logger() -> ActionLogger:
+    """Get the global action logger instance."""
+    global _action_logger
+    if _action_logger is None:
+        _action_logger = ActionLogger()
+    return _action_logger