omoshiroi-packager 0.1.0__tar.gz

omoshiroi_packager-0.1.0/.env.example

@@ -0,0 +1,11 @@
+# Omoshiroi Packager Configuration
+# Copy this file to .env and update the paths
+
+# Directory for manifest files
+MANIFEST_DIR=/path/to/manifests
+
+# Root directory of the project
+PROJECT_DIR=/path/to/project
+
+# Temporary directory for build artifacts
+TMP_DIR=/path/to/tmp

omoshiroi_packager-0.1.0/LICENSE

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

omoshiroi_packager-0.1.0/MANIFEST.in

@@ -0,0 +1,14 @@
+# Include files for distribution
+include README.md
+include LICENSE
+include pyproject.toml
+include .env.example
+
+# Exclude test files
+prune tests/
+prune .github/
+
+# Exclude development files
+exclude build.py
+exclude .gitignore
+exclude .pre-commit-config.yaml

omoshiroi_packager-0.1.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: omoshiroi-packager
+Version: 0.1.0
+Summary: Version parser with multiple channels support
+Author-email: ovcharenski <stun.bread.frog@outlook.com>
+License: MIT
+Project-URL: Homepage, https://ns-staff.ovcharenski.ru/projects/omoshiroi-packager
+Project-URL: Repository, https://github.com/ovcharenski/omoshiroi-packager
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: build>=0.10.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: license-file
+
+# Omoshiroi Packager
+
+Python package for parsing and comparing software versions with multiple channels.
+
+## Installation
+
+```bash
+pip install omoshiroi-packager

omoshiroi_packager-0.1.0/README.md

@@ -0,0 +1,8 @@
+# Omoshiroi Packager
+
+Python package for parsing and comparing software versions with multiple channels.
+
+## Installation
+
+```bash
+pip install omoshiroi-packager

omoshiroi_packager-0.1.0/omoshiroi_packager/__init__.py

@@ -0,0 +1,96 @@
+"""
+Omoshiroi Packager - Version management and packaging utilities.
+
+A comprehensive package for parsing, comparing, and managing software versions
+with multiple channel support (dev, alpha, beta, rc, stable, hotfix).
+"""
+
+from .config import Config
+from .core import ManifestManager, Packager, Updater
+from .exceptions import (
+    ConfigError,
+    FileError,
+    HashError,
+    ManifestError,
+    PackageError,
+    PackError,
+    VersionError,
+)
+from .models import FileProperties, Manifest, UpdateCheckResult
+from .packages import (
+    check_update,
+    get_all_versions,
+    get_latest_version,
+    make_manifest,
+    pack_by_channel,
+    pack_version,
+    reset_config,
+)
+from .utils import (
+    IgnorePattern,
+    ProjectConfig,
+    ProjectFiles,
+    create_zip_from_files,
+    extract_zip,
+    generate_file_hash,
+    get_zip_file_list,
+    verify_file_hash,
+)
+from .version import (
+    InvalidVersion,  # ← ДОБАВИТЬ ЭТО
+    Version,
+    is_valid,
+    latest_stable,
+    latest_version,
+    parse,
+    sort_versions,
+)
+
+__version__ = "0.1.0"
+__author__ = "ovcharenski"
+
+__all__ = [
+    # Version
+    "InvalidVersion",  # ← ДОБАВИТЬ ЭТО
+    "Version",
+    "parse",
+    "is_valid",
+    "sort_versions",
+    "latest_version",
+    "latest_stable",
+    # Config
+    "Config",
+    # Models
+    "Manifest",
+    "FileProperties",
+    "UpdateCheckResult",
+    # Exceptions
+    "PackageError",
+    "ManifestError",
+    "FileError",
+    "HashError",
+    "VersionError",
+    "ConfigError",
+    "PackError",
+    # Main API
+    "get_latest_version",
+    "check_update",
+    "pack_version",
+    "pack_by_channel",
+    "make_manifest",
+    "get_all_versions",
+    "reset_config",
+    # Core
+    "ManifestManager",
+    "Packager",
+    "Updater",
+    # Utils
+    "IgnorePattern",
+    "ProjectFiles",
+    "ProjectConfig",
+    "generate_file_hash",
+    "verify_file_hash",
+    "create_zip_from_files",
+    "extract_zip",
+    "get_zip_file_list",
+]

omoshiroi_packager-0.1.0/omoshiroi_packager/config.py

@@ -0,0 +1,104 @@
+"""
+Configuration management for the packages module.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from .exceptions import ConfigError
+
+
+@dataclass
+class Config:
+    """
+    Application configuration.
+    
+    Attributes:
+        manifest_dir: Directory for manifest files
+        project_dir: Root directory of the project
+        tmp_dir: Temporary directory for build artifacts
+    """
+    
+    manifest_dir: Path
+    project_dir: Path
+    tmp_dir: Path
+    
+    @classmethod
+    def from_env(cls, load_dotenv_file: bool = True) -> Config:
+        """
+        Create configuration from environment variables.
+        
+        Args:
+            load_dotenv_file: Whether to load .env file
+            
+        Returns:
+            Config instance
+            
+        Raises:
+            ConfigError: If required variables are missing
+        """
+        if load_dotenv_file:
+            load_dotenv()
+        
+        manifest_dir = os.getenv("MANIFEST_DIR")
+        project_dir = os.getenv("PROJECT_DIR")
+        tmp_dir = os.getenv("TMP_DIR")
+        
+        missing = []
+        if not manifest_dir:
+            missing.append("MANIFEST_DIR")
+        if not project_dir:
+            missing.append("PROJECT_DIR")
+        if not tmp_dir:
+            missing.append("TMP_DIR")
+        
+        if missing:
+            raise ConfigError(
+                f"Missing required environment variables: {', '.join(missing)}"
+            )
+        
+        return cls(
+            manifest_dir=Path(manifest_dir),
+            project_dir=Path(project_dir),
+            tmp_dir=Path(tmp_dir),
+        )
+    
+    def ensure_directories(self) -> None:
+        """Ensure all required directories exist."""
+        for dir_path in [self.manifest_dir, self.tmp_dir]:
+            dir_path.mkdir(parents=True, exist_ok=True)
+    
+    @property
+    def manifest_stable_path(self) -> Path:
+        """Path to stable manifest file."""
+        return self.manifest_dir / "manifest-stable.json"
+    
+    @property
+    def manifest_beta_path(self) -> Path:
+        """Path to beta manifest file."""
+        return self.manifest_dir / "manifest-beta.json"
+    
+    def get_manifest_path(self, channel: str) -> Path:
+        """
+        Get manifest path for a channel.
+        
+        Args:
+            channel: Channel name (stable, beta, dev, etc.)
+            
+        Returns:
+            Path to manifest file
+        """
+        return self.manifest_dir / f"manifest-{channel}.json"
+    
+    def get_ignore_file_path(self) -> Path:
+        """Get path to .ignore file."""
+        return self.project_dir / ".ignore"
+    
+    def get_config_file_path(self) -> Path:
+        """Get path to .config file."""
+        return self.project_dir / ".config"

omoshiroi_packager-0.1.0/omoshiroi_packager/core/__init__.py

@@ -0,0 +1,11 @@
+"""Core functionality for omoshiroi-packager."""
+
+from .manifest import ManifestManager
+from .packager import Packager
+from .updater import Updater
+
+__all__ = [
+    "ManifestManager",
+    "Packager",
+    "Updater",
+]

omoshiroi_packager-0.1.0/omoshiroi_packager/core/manifest.py

@@ -0,0 +1,160 @@
+"""
+Manifest management for the packages module.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from ..config import Config
+from ..models import FileProperties, Manifest
+from ..exceptions import ManifestError
+from ..utils.file_utils import ProjectFiles
+from ..utils.hash_utils import generate_file_hash
+
+
+class ManifestManager:
+    """Manager for package manifests."""
+
+    def __init__(self, config: Config):
+        """
+        Initialize manifest manager.
+
+        Args:
+            config: Application configuration
+        """
+        self.config = config
+        self._cache: Dict[str, Optional[Manifest]] = {}
+
+    def create_manifest(
+        self,
+        version: str,
+        channel: str,
+        project_files: Optional[ProjectFiles] = None,
+    ) -> Manifest:
+        """
+        Create a new manifest for a version.
+
+        Args:
+            version: Version string
+            channel: Channel name
+            project_files: ProjectFiles instance (creates new if not provided)
+
+        Returns:
+            Manifest object
+        """
+        if project_files is None:
+            project_files = ProjectFiles(self.config.project_dir)
+
+        files_list = []
+        for file_path in project_files.get_files():
+            full_path = project_files.get_full_path(file_path)
+
+            if full_path.exists():
+                sha256, sha512 = generate_file_hash(full_path)
+                files_list.append(
+                    FileProperties(
+                        path=file_path,
+                        size=full_path.stat().st_size,
+                        sha256=sha256,
+                        sha512=sha512,
+                    )
+                )
+
+        return Manifest(
+            version=version,
+            channel=channel,
+            timestamp=int(time.time()),
+            files=files_list,
+        )
+
+    def save_manifest(self, manifest: Manifest, channel: Optional[str] = None) -> Path:
+        """
+        Save a manifest to disk.
+
+        Args:
+            manifest: Manifest object
+            channel: Channel name (uses manifest.channel if not provided)
+
+        Returns:
+            Path to saved manifest file
+        """
+        channel = channel or manifest.channel
+        manifest_path = self.config.get_manifest_path(channel)
+
+        # Ensure manifest directory exists
+        manifest_path.parent.mkdir(parents=True, exist_ok=True)
+
+        try:
+            with open(manifest_path, "w", encoding="utf-8") as f:
+                json.dump(manifest.to_dict(), f, indent=2)
+        except OSError as e:
+            raise ManifestError(f"Failed to save manifest {manifest_path}: {e}")
+
+        return manifest_path
+
+    def load_manifest(self, channel: str) -> Optional[Manifest]:
+        """
+        Load a manifest from disk.
+
+        Args:
+            channel: Channel name
+
+        Returns:
+            Manifest object or None if not found
+        """
+        # Check cache
+        if channel in self._cache:
+            return self._cache[channel]
+
+        manifest_path = self.config.get_manifest_path(channel)
+
+        if not manifest_path.exists():
+            return None
+
+        try:
+            with open(manifest_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+
+            manifest = Manifest.from_dict(data)
+            self._cache[channel] = manifest
+            return manifest
+
+        except (OSError, json.JSONDecodeError) as e:
+            raise ManifestError(f"Failed to load manifest {manifest_path}: {e}")
+
+    def get_version(self, channel: str) -> Optional[str]:
+        """
+        Get version from a channel's manifest.
+
+        Args:
+            channel: Channel name
+
+        Returns:
+            Version string or None
+        """
+        manifest = self.load_manifest(channel)
+        return manifest.version if manifest else None
+
+    def get_all_manifests(self) -> Dict[str, Optional[Manifest]]:
+        """
+        Get manifests for all channels.
+
+        Returns:
+            Dictionary mapping channel to Manifest
+        """
+        # Channels list - can be extended
+        channels = ["dev", "alpha", "beta", "rc", "stable", "hotfix"]
+
+        result = {}
+        for channel in channels:
+            result[channel] = self.load_manifest(channel)
+
+        return result
+
+    def clear_cache(self) -> None:
+        """Clear the manifest cache."""
+        self._cache.clear()

omoshiroi_packager-0.1.0/omoshiroi_packager/core/packager.py

@@ -0,0 +1,108 @@
+"""
+Packaging functionality for the packages module.
+"""
+
+from __future__ import annotations
+
+from io import BytesIO
+from pathlib import Path
+from typing import Optional, Tuple
+
+from ..config import Config
+from ..exceptions import PackError
+from ..utils.file_utils import ProjectFiles, ProjectConfig
+from ..utils.zip_utils import create_zip_from_files
+from ..version import parse
+from .manifest import ManifestManager
+
+
+class Packager:
+    """Handler for packaging versions."""
+
+    def __init__(self, config: Config):
+        """
+        Initialize packager.
+
+        Args:
+            config: Application configuration
+        """
+        self.config = config
+        self.manifest_manager = ManifestManager(config)
+
+    def pack_version(
+        self,
+        version: Optional[str] = None,
+        channel: Optional[str] = None,
+    ) -> Tuple[BytesIO, Path]:
+        """
+        Package a version.
+
+        Args:
+            version: Version string (reads from .config if not provided)
+            channel: Channel name (parsed from version if not provided)
+
+        Returns:
+            Tuple of (zip_data, manifest_path)
+
+        Raises:
+            PackError: If packaging fails
+        """
+        try:
+            # Get version from config if not provided
+            if version is None:
+                project_config = ProjectConfig(self.config.get_config_file_path())
+                version = project_config.get_version()
+
+                if version is None:
+                    raise PackError("Version not found in .config file")
+
+            # Parse channel from version if not provided
+            if channel is None:
+                version_obj = parse(version)
+                channel = version_obj.channel
+
+            # Create project files handler
+            project_files = ProjectFiles(self.config.project_dir)
+
+            # Create manifest
+            manifest = self.manifest_manager.create_manifest(
+                version=version,
+                channel=channel,
+                project_files=project_files,
+            )
+
+            # Save manifest
+            manifest_path = self.manifest_manager.save_manifest(manifest, channel)
+
+            # Get files to zip
+            files = project_files.get_files()
+
+            # Create ZIP archive
+            zip_data = create_zip_from_files(
+                files=files,
+                base_dir=self.config.project_dir,
+                manifest_path=manifest_path,
+            )
+
+            return zip_data, manifest_path
+
+        except Exception as e:
+            raise PackError(f"Failed to pack version: {e}")
+
+    def pack_by_channel(self, channel: str) -> Tuple[BytesIO, Path]:
+        """
+        Package the latest version for a channel.
+
+        Args:
+            channel: Channel name
+
+        Returns:
+            Tuple of (zip_data, manifest_path)
+        """
+        # Get version from manifest
+        version = self.manifest_manager.get_version(channel)
+
+        if version is None:
+            raise PackError(f"No version found for channel: {channel}")
+
+        return self.pack_version(version, channel)