deflacue 2.1.0__py3-none-any.whl

deflacue/__init__.py

@@ -0,0 +1 @@
+VERSION = '2.1.0'

deflacue/cli.py

@@ -0,0 +1,63 @@
+import argparse
+import logging
+
+from .deflacue import Deflacue, DeflacueError
+
+
+def main():
+
+    argparser = argparse.ArgumentParser('deflacue')
+
+    argparser.add_argument(
+        'source_path', help='Absolute or relative source path with .cue file(s).')
+    argparser.add_argument(
+        '-r', help='Recursion flag to search directories under the source_path.', action='store_true')
+    argparser.add_argument(
+        '-d', help='Absolute or relative destination path for output audio file(s).')
+    argparser.add_argument(
+        '-e', help='Cue Sheet file(s) encoding.')
+    argparser.add_argument(
+        '--dry', help='Perform the dry run with no changes done to filesystem.', action='store_true')
+    argparser.add_argument(
+        '--delete-source', help='Delete source audio and .cue file(s) after successful extraction.',
+        action='store_true')
+    argparser.add_argument(
+        '--no-bundle-path', help='Write output files directly to the target path, '
+                                 'without the Artist/Album directory structure.',
+        action='store_true')
+    argparser.add_argument(
+        '--debug', help='Show debug messages while processing.', action='store_true')
+
+    parsed = argparser.parse_args()
+    kwargs = {'source_path': parsed.source_path}
+
+    if parsed.e is not None:
+        kwargs['encoding'] = parsed.e
+
+    if parsed.d is not None:
+        kwargs['dest_path'] = parsed.d
+
+    if parsed.debug:
+        kwargs['use_logging'] = logging.DEBUG
+
+    if parsed.delete_source:
+        kwargs['delete_source'] = True
+
+    if parsed.no_bundle_path:
+        kwargs['use_bundle_path'] = False
+
+    try:
+        deflacue = Deflacue(**kwargs)
+
+        if not deflacue.sox_check_is_available():
+            raise DeflacueError(
+                'SoX seems not available. Please install it (e.g. `sudo apt-get install sox libsox-fmt-all`).'
+            )
+
+        if parsed.dry:
+            deflacue.set_dry_run()
+
+        deflacue.do(recursive=parsed.r)
+
+    except DeflacueError as e:
+        logging.error(e)

deflacue/deflacue.py

@@ -0,0 +1,393 @@
+"""
+deflacue is a Cue Sheet parser and a wrapper for mighty SoX utility - http://sox.sourceforge.net/.
+
+SoX with appropriate plugins should be installed for deflacue to function.
+Ubuntu users may install the following SoX packages: `sox`, `libsox-fmt-all`.
+
+deflacue can function both as a Python module and in command line mode.
+
+"""
+import logging
+import os
+import re
+import sys
+from collections import defaultdict
+from pathlib import Path
+from subprocess import Popen, PIPE
+from typing import List, Dict, Union
+
+from .exceptions import DeflacueError
+from .parser import CueParser
+
+LOGGER = logging.getLogger(__name__)
+TypePath = Union[str, Path]
+
+
+COMMENTS_CUE_TO_VORBIS = {
+    'TRACK_NUM': 'TRACKNUMBER',
+    'TITLE': 'TITLE',
+    'PERFORMER': 'ARTIST',
+    'ALBUM': 'ALBUM',
+    'GENRE': 'GENRE',
+    'DATE': 'DATE',
+    'ISRC': 'ISRC',
+    'COMMENT': 'DESCRIPTION',
+}
+"""Cue REM commands to Vorbis tags."""
+
+RE_NAME_INVALID_WIN = re.compile(r'[<>:"/\\|?*]')
+"""Characters invalid in file and directory names on Windows."""
+
+
+def sanitize_name(value: str) -> str:
+    """Removes characters invalid for the target filesystem from a given file or directory name.
+
+    On Windows also strips characters invalid there, as well as trailing dots
+    and spaces, which are silently pruned by the OS, leading to a mismatch
+    between computed and actually created paths.
+
+    :param value:
+
+    """
+    value = value.replace('/', '')
+
+    if sys.platform == 'win32':
+        value = RE_NAME_INVALID_WIN.sub('', value).rstrip('. ')
+
+    return value
+
+
+class Deflacue:
+    """deflacue functionality is encapsulated in this class.
+
+    Usage example:
+        deflacue = Deflacue('/home/idle/cues_to_process/')
+        deflacue.do()
+
+    This will search `/home/idle/cues_to_process/` and subdirectories
+    for .cue files, parse them and extract separate tracks.
+    Extracted tracks are stored in Artist - Album hierarchy within
+    `deflacue` directory under each source directory.
+
+    """
+    _dry_run = False  # Some lengthy shell command won't be executed on dry run.
+    _target_default = 'deflacue'
+
+    def __init__(
+        self,
+        source_path: TypePath,
+        *,
+        dest_path: TypePath | None = None,
+        encoding: str | None = None,
+        use_logging: int = logging.INFO,
+        delete_source: bool = False,
+        use_bundle_path: bool = True
+    ):
+        """Prepares deflacue to for audio processing.
+
+        :param source_path: Absolute or relative to the current directory path,
+            containing .cue file(s) or subdirectories with .cue file(s) to process.
+
+        :param dest_path: Absolute or relative to the current directory path
+            to store output files in. If None, output files are saved in `deflacue` directory
+            in the same directory as input file(s).
+
+        :param encoding: Encoding used for .cue file(s).
+
+        :param use_logging: Defines the verbosity level of deflacue. All messages
+            produced by the application are logged with `logging` module.
+            Examples: logging.INFO, logging.DEBUG.
+
+        :param delete_source: If True, source audio file(s) and .cue file are deleted
+            after all tracks were extracted successfully.
+
+        :param use_bundle_path: If False, output files are written directly to the target
+            path, without the Artist/Album directory structure.
+
+        """
+        src = Path(source_path).absolute()
+        self.path_source: Path = src
+        self.path_target: Path | None = dest_path
+        self.encoding = encoding
+        self._delete_source = delete_source
+        self._use_bundle_path = use_bundle_path
+
+        if use_logging:
+            self._configure_logging(use_logging)
+
+        LOGGER.info('Source path: %s', src)
+
+        if not src.exists():
+            raise DeflacueError(f'Path `{src}` is not found.')
+
+        if dest_path is not None:
+            self.path_target = Path(dest_path).absolute()
+            os.chdir(src)
+
+    def _process_command(
+        self,
+        command: str,
+        *,
+        stdout=None,
+        suppress_dry_run: bool = False
+    ) -> int:
+        """Executes shell command with subprocess.Popen.
+        Returns status code.
+
+        """
+        LOGGER.debug('Executing shell command: %s', command)
+
+        if not self._dry_run or suppress_dry_run:
+            prc = Popen(command, shell=True, stdout=stdout)
+            prc.communicate()
+            return prc.returncode
+
+        return 0
+
+    @classmethod
+    def _configure_logging(cls, verbosity_lvl: int = logging.INFO):
+        """Switches on logging at given level."""
+        logging.basicConfig(level=verbosity_lvl, format='%(levelname)s: %(message)s')
+
+    def _create_target_path(self, path: Path | None):
+        """Creates a directory for target files."""
+        if self._dry_run or not path:
+            return
+
+        LOGGER.debug('Creating target path: %s ...', path)
+        Path(path).mkdir(parents=True, exist_ok=True)
+
+    def set_dry_run(self):
+        """Sets deflacue into dry run mode, when all requested actions
+        are only simulated, and no changes are written to filesystem.
+
+        """
+        self._dry_run = True
+
+    def get_dir_files(self, *, recursive: bool = False) -> Dict[Path, List[Path]]:
+        """Creates and returns dictionary of files in source directory.
+
+        :param recursive: if True search is also performed within subdirectories.
+
+        """
+        LOGGER.info('Enumerating files under the source path (recursive=%s) ...', recursive)
+
+        files = {}
+        if recursive:
+            for current_dir, _, dir_files in os.walk(self.path_source):
+                path = self.path_source / current_dir
+                files[path] = [path / f for f in dir_files]
+
+        else:
+            files[self.path_source] = [
+                f for f in self.path_source.iterdir()
+                if f.is_file()
+            ]
+
+        return files
+
+    def filter_target_extensions(self, files_dict: Dict[Path, List[Path]]) -> Dict[Path, List[Path]]:
+        """Takes file dictionary created with `get_dir_files` and returns
+        dictionary of the same kind containing only files of supported
+        types.
+
+        :param files_dict:
+
+        """
+        files_filtered = defaultdict(list)
+        LOGGER.info('Filtering .cue files ...')
+        paths = files_dict.keys()
+
+        for path in paths:
+
+            if path.name == self._target_default:
+                continue
+
+            for f in sorted(files_dict[path]):
+                if f.suffix == '.cue':
+                    files_filtered[path].append(f)
+
+        return files_filtered
+
+    def sox_check_is_available(self) -> bool:
+        """Checks whether SoX is available."""
+        result = self._process_command('sox -h', stdout=PIPE, suppress_dry_run=True)
+        return result == 0
+
+    def sox_extract_audio(
+        self,
+        *,
+        source_file: Path,
+        pos_start_samples: int,
+        pos_end_samples: int,
+        target_file: Path,
+        metadata: Dict[str, str] | None = None
+    ) -> bool:
+        """Using SoX extracts a chunk from source audio file into target.
+
+        :param source_file: Source audio file path
+
+        :param pos_start_samples: Trim position start (samples)
+
+        :param pos_end_samples: Trim position end (samples)
+
+        :param target_file: Trimmed audio file path
+
+        :param metadata: Additional data (tags) dict.
+
+        Returns whether extraction succeeded.
+
+        """
+        LOGGER.info('  Extracting `%s` ...', target_file.name)
+
+        chunk_length_samples = ''
+        if pos_end_samples:
+            chunk_length_samples = f'{pos_end_samples - pos_start_samples}s'
+
+        add_comment = ''
+        if metadata is not None:
+            LOGGER.debug('Metadata: %s\n', metadata)
+
+            for key, val in COMMENTS_CUE_TO_VORBIS.items():
+                val_meta = metadata.get(key)
+                if val_meta:
+                    add_comment = f'--add-comment="{val}={val_meta}" {add_comment}'
+
+        LOGGER.debug(
+            'Extraction information:\n'
+            '      Source file: %s\n'
+            '      Start position: %s samples\n'
+            '      End position: %s samples\n'
+            '      Length: %s sample(s)',
+            source_file, pos_start_samples, pos_end_samples, chunk_length_samples)
+
+        command = (
+            f'sox -V1 "{source_file}" '
+            f'--comment="" {add_comment} "{target_file}" '
+            f'trim {pos_start_samples}s {chunk_length_samples}'
+        )
+
+        return self._process_command(command, stdout=PIPE) == 0
+
+    def process_cue(self, *, cue_file: Path, target_path: Path):
+        """Parses .cue file, extracts separate tracks.
+
+        :param cue_file: .cue filepath
+
+        :param target_path: path to place files into
+
+        """
+        LOGGER.info('\nProcessing `%s`\n', cue_file.name)
+
+        parser = CueParser.from_file(fpath=cue_file, encoding=self.encoding)
+        cue = parser.run()
+
+        cd_info = cue.meta.data
+        tracks = cue.tracks
+
+        title = cd_info['ALBUM']
+        if cd_info['DATE'] is not None:
+            title = f"{cd_info['DATE']} - {title}"
+
+        if self._use_bundle_path:
+            bundle_path = target_path / sanitize_name(cd_info['PERFORMER']) / sanitize_name(title)
+
+        else:
+            bundle_path = target_path
+        self._create_target_path(bundle_path)
+
+        len_tracks_count = len(str(len(tracks)))
+        source_files: set[Path] = set()
+        has_failures = False
+
+        for track in tracks:
+            track_file = track.file.path
+            source_files.add(track_file)
+
+            if not track_file.exists():
+                LOGGER.error('Source file `%s` is not found. Track is skipped.', track_file)
+                has_failures = True
+                continue
+
+            track_num = str(track.num).rjust(len_tracks_count, '0')
+            filename = f"{track_num} - {sanitize_name(track.title)}.flac"
+
+            extracted = self.sox_extract_audio(
+                source_file=track_file,
+                pos_start_samples=track.start,
+                pos_end_samples=track.end,
+                target_file=bundle_path / filename,
+                metadata=track.data
+            )
+
+            if not extracted:
+                has_failures = True
+
+        if self._delete_source:
+            self._delete_source_files(cue_file=cue_file, source_files=source_files, has_failures=has_failures)
+
+    def _delete_source_files(self, *, cue_file: Path, source_files: set[Path], has_failures: bool):
+        """Deletes source audio file(s) and the .cue file after successful processing.
+
+        :param cue_file: .cue filepath
+
+        :param source_files: Audio files referenced by the .cue file
+
+        :param has_failures: Whether some tracks were not extracted
+
+        """
+        if has_failures:
+            LOGGER.warning("Some tracks were not extracted. Source files are kept for: %s", cue_file.name)
+            return
+
+        if self._dry_run:
+            return
+
+        for source_file in sorted(source_files):
+            LOGGER.info("  Deleting `%s` ...", source_file.name)
+            source_file.unlink()
+
+        LOGGER.info("  Deleting `%s` ...", cue_file.name)
+        cue_file.unlink()
+
+    def do(self, *, recursive: bool = False):
+        """Main method processing .cue files in batch.
+
+        :param recursive: if True .cue search is also performed within subdirectories.
+
+        """
+        self._create_target_path(self.path_target)
+
+        files_dict = self.filter_target_extensions(self.get_dir_files(recursive=recursive))
+
+        dir_initial = Path.cwd()
+        paths = sorted(files_dict.keys())
+
+        for path in paths:
+            os.chdir(path)
+
+            LOGGER.info('\n%s\nWorking on: %s\n', '====' * 10, path)
+
+            if self.path_target is None:
+                # When a target path is not specified, create `deflacue` subdirectory
+                # in every directory we are working at.
+                target_path = path / self._target_default
+
+            elif self._use_bundle_path:
+                # When a target path is specified, we create a subdirectory there
+                # named after the directory we are working on.
+                target_path = self.path_target / path.name
+
+            else:
+                target_path = self.path_target
+
+            self._create_target_path(target_path)
+
+            LOGGER.info('Target (output) path: %s', target_path)
+
+            for cue in files_dict[path]:
+                self.process_cue(cue_file=path / cue, target_path=target_path)
+
+        os.chdir(dir_initial)
+
+        LOGGER.info('We are done. Thank you.\n')

deflacue/exceptions.py

@@ -0,0 +1,7 @@
+
+class DeflacueError(Exception):
+    """Exception type raised by deflacue."""
+
+
+class ParserError(Exception):
+    """Cue file parser error."""

deflacue/parser.py

@@ -0,0 +1,243 @@
+import logging
+from copy import deepcopy
+from pathlib import Path
+from typing import List, Tuple
+
+from .exceptions import ParserError
+
+LOGGER = logging.getLogger(__name__)
+
+
+def pos_to_frames(pos) -> int:
+    """Converts position (mm:ss:ff) into frames.
+
+    :param pos:
+
+    """
+    minutes, seconds, frames = map(int, pos.split(':'))
+    seconds = (minutes * 60) + seconds
+    rate = 44100
+    return (seconds * rate) + (frames * (rate // 75))
+
+
+class Context:
+    """Basic context."""
+
+    _default = {}
+
+    def __init__(self, *, data: dict):
+        self.data = {**self._default, **deepcopy(data)}
+
+    def add(self, key: str, val: str):
+        self.data[key] = val
+
+
+class MetaContext(Context):
+    """Global .cue meta context."""
+
+    _default = {
+        'ALBUM': 'Unknown',
+        'PERFORMER': 'Unknown',
+        'DATE': None,
+    }
+
+    def add(self, key: str, val: str):
+        if key == 'TITLE':
+            key = 'ALBUM'
+        super().add(key, val)
+
+
+class FileContext(Context):
+    """File information."""
+
+    def __init__(self, *, path: str, ftype: str, data: dict):
+        self.path: Path = Path(path)
+        """File path."""
+
+        self.type = ftype
+        """File type."""
+
+        self.tracks: List[TrackContext] = []
+        """Tracks in file."""
+
+        super().__init__(data=data)
+
+    def __str__(self):
+        return str(self.path)
+
+
+class TrackContext(Context):
+    """Track information."""
+
+    _default = {
+        'TITLE': 'Unknown',
+    }
+
+    def __init__(self, *, file: FileContext, num: int, dtype: str):
+        self.file = file
+        """File containing track."""
+
+        self.num = num
+        """Track number."""
+
+        self.type = dtype
+        """Track data type."""
+
+        self.start: int = 0
+        """Start position (frames)."""
+
+        super().__init__(data=file.data)
+
+    def __str__(self):
+        return f"{self.num} {self.title} @ {self.file}"
+
+    @property
+    def title(self):
+        return self.data.get('TITLE', '')
+
+    @property
+    def end(self) -> int:
+        tracks = self.file.tracks
+        end = 0
+
+        for idx, track in enumerate(tracks):
+            if track is self:
+                try:
+                    end = tracks[idx+1].start
+
+                except IndexError:
+                    pass
+
+                break
+
+        return end
+
+
+class CueData:
+    """Represents data from .cue file."""
+
+    def __init__(self):
+        self.meta = []
+
+        self.meta = MetaContext(data={})
+        """Basic information."""
+
+        self.files: List[FileContext] = []
+        """Files in image."""
+
+        self.tracks: List[TrackContext] = []
+        """Tracks in image."""
+
+        self._current_file: FileContext | None = None
+        self._current_track: TrackContext | None = None
+        self._current_context: Context = self.meta
+
+    def add_context(self, key, val):
+        self._current_context.add(key, val)
+
+    def add_file(self, *, path: str, ftype: str):
+        file_context = FileContext(
+            path=path,
+            ftype=ftype,
+            data=self._current_context.data
+        )
+        self._current_context = file_context
+        self._current_file = file_context
+        self.files.append(file_context)
+
+    def add_track(self, *, num: int, dtype: str):
+        file_context = self._current_file
+        track_context = TrackContext(
+            file=self._current_file,
+            num=num,
+            dtype=dtype,
+        )
+        track_context.add('TRACK_NUM', f'{num}')
+        file_context.tracks.append(track_context)
+        self._current_context = track_context
+        self._current_track = track_context
+        self.tracks.append(track_context)
+
+    def add_track_index(self, *, pos: str):
+        self._current_track.start = pos_to_frames(pos)
+
+
+class CueParser:
+    """Simple Cue Sheet file parser."""
+
+    def __init__(self, lines: List[str]):
+        self.lines = lines
+
+    def run(self) -> CueData:
+
+        cue = CueData()
+        parse_cmd = self._parse_command
+        unquote = self._unquote
+
+        for line in self.lines:
+            cmd, args = parse_cmd(line)
+
+            if cmd == 'REM':
+                cue.add_context(*parse_cmd(args))
+
+            elif cmd == 'FILE':
+                fpath, ftype = args.rsplit(' ', 1)
+                fpath = unquote(fpath)
+                cue.add_file(path=fpath, ftype=ftype)
+
+            elif cmd == 'TRACK':
+                num, _, dtype = args.partition(' ')
+                cue.add_track(num=int(num), dtype=dtype)
+
+            elif cmd == 'INDEX':
+                num, _, pos = args.partition(' ')
+
+                if num == '01':
+                    cue.add_context(f'{cmd} {num}', pos)
+                    cue.add_track_index(pos=pos)
+
+            else:
+                cue.add_context(cmd, args)
+
+        return cue
+
+    def _parse_command(self, cmd: str) -> Tuple[str, str]:
+        command, _, args = cmd.partition(' ')
+        args = self._unquote(args)
+
+        LOGGER.debug('Parsed command `%s`. Args: %s', command, args)
+
+        return command, args
+
+    @classmethod
+    def _unquote(cls, val: str) -> str:
+        return val.strip(' "')
+
+    @classmethod
+    def from_file(cls, fpath: Path, *, encoding: str | None = None) -> 'CueParser':
+
+        def read(coding: str | None = None) -> CueParser | None:
+
+            try:
+                with Path(str(fpath)).open(encoding=coding) as f:
+                    return CueParser([
+                        line.strip() for line in f
+                        if line.strip()
+                    ])
+
+            except UnicodeDecodeError:
+                return None
+
+        parser = read(encoding)
+
+        if not parser:
+            # Try unicode as a fallback.
+            parser = read()
+
+        if not parser:
+            raise ParserError(
+                'Unable to read data from .cue file. '
+                'Please provide a correct encoding.'
+            )
+
+        return parser

deflacue-2.1.0.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.5
+Name: deflacue
+Version: 2.1.0
+Summary: SoX based audio splitter to split audio CD images incorporated with .cue files
+Project-URL: Homepage, https://github.com/idlesign/deflacue
+Author-email: Igor Starikov <idlesign@yandex.ru>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Keywords: audio,cue,flac,sox
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# deflacue
+
+<https://github.com/idlesign/deflacue>
+
+[![release](https://img.shields.io/pypi/v/deflacue.svg)](https://pypi.python.org/pypi/deflacue)
+[![lic](https://img.shields.io/pypi/l/deflacue.svg)](https://pypi.python.org/pypi/deflacue)
+[![coverage](https://img.shields.io/coveralls/idlesign/deflacue/master.svg)](https://coveralls.io/r/idlesign/deflacue)
+
+## What's that
+
+*deflacue is a SoX based audio splitter appropriate to split audio CD images incorporated with .cue files.*
+
+It is able to function both as a Python module and in command line mode.
+
+## Features
+
+- Large variety of supported lossless input audio formats FLAC, WAV, etc. (due to SoX).
+- Batch audio files processing (including recursive path traversing).
+- Automatic audio collection hierarchy building (Artist/Year-Album/Tracknum-Title).
+- Automatic track metadata copying from .cue.
+
+## Requirements
+
+* Python 3.10+
+* SoX command line utility — <http://sox.sourceforge.net>.
+
+  Ubuntu users may install the following SoX packages: `sox`, `libsox-fmt-all`.
+
+## Usage
+
+### From Python
+
+`from deflacue import deflacue` — if you want to use it as module.
+
+Use `Deflacue` class for SoX interaction.
+
+Use `CueParser` class for .cue parsing.
+
+### From Command Line
+
+`deflacue --help` in command line — to get help on utility usage.
+
+In the following example we create audio collection in `/home/idle/audio_collection/` from audio CD images
+stored under `/home/idle/audio_raw/` processing Cue Sheet files created using `windows-1251` encoding:
+
+```shell
+$ deflacue -e windows-1251 /home/idle/audio_raw/ -d /home/idle/audio_collection/
+```

deflacue-2.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+deflacue/__init__.py,sha256=s5F39ikwvanccisuElhg0gEoVBisSR9dXR281TnsnzQ,18
+deflacue/cli.py,sha256=65BxhtuFzpIxs8TFvSXa9u790tnCz59WiVTZ2sx8jK0,2052
+deflacue/deflacue.py,sha256=c6lQk-416823mM46K09jHoJrFHe0GozxeOjrUyJGaiM,12724
+deflacue/exceptions.py,sha256=qwmg5gEhqe0zbyNZamjD7u9cy7jvh-q9fZeiKpZDOBM,143
+deflacue/parser.py,sha256=E9Aw2D29O1YIhMwSanehA0LCyien6yczIIctmbiUZDs,5940
+deflacue-2.1.0.dist-info/METADATA,sha256=7ovWvtWc2A0gQNa-0Q3S95ffKT3u0g5HN7spNisvv6I,2556
+deflacue-2.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+deflacue-2.1.0.dist-info/entry_points.txt,sha256=OylZ8m7onZIA0Hojxhek8-XucsFH8LyPGBBVgwNrcu0,47
+deflacue-2.1.0.dist-info/licenses/LICENSE,sha256=LXASjE5Quh7Pa7ZuYjUdPZxHTP2VA4PUikEBzgofQgE,1539
+deflacue-2.1.0.dist-info/RECORD,,

deflacue-2.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

deflacue-2.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+deflacue = deflacue.cli:main

deflacue-2.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2012-2026, Igor 'idle sign' Starikov
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+    3. Neither the name of the deflacue nor the names of its
+       contributors may be used to endorse or promote products derived from
+       this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.