releascenify 0.1.0__tar.gz

releascenify-0.1.0/LICENSE

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

releascenify-0.1.0/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: releascenify
+Version: 0.1.0
+Summary: A regex-based Python library to parse scene release names and extract technical metadata
+License: MIT License
+        
+        Copyright (c) 2026 Denis Machard
+        
+        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.
+        
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Dynamic: license-file
+
+# Releascenify
+
+A robust, regex-based Python library to parse scene release names and extract technical metadata (title, year, resolution, quality, codec, audio, languages, etc.).
+
+**Live Demo & Web Interface:** [https://dmachard.github.io/releascenify/docs/](https://dmachard.github.io/releascenify/docs/)
+
+## Why?
+Release names follow a strict grammar inherited from the Scene and P2P groups. Once decoded, you can predict the quality, source, language, and release group just from the filename. This library is a modernized alternative to PTN (Parse Torrent Name).
+
+## Installation
+*(To be published on PyPI)*
+
+## Usage
+
+```python
+from releascenify import parse_filename
+from releascenify.comparator import get_quality_score, is_better_release
+
+filename = "Gladiator.II.2024.MULTi.2160p.WEB-DL.DV.HDR.H265-GROUP"
+parsed = parse_filename(filename)
+
+print(parsed)
+# {
+#   "title": "Gladiator II",
+#   "year": 2024,
+#   "resolution": "2160P",
+#   "quality": "WEB-DL",
+#   "v_quality": "HDR DV",
+#   "codec": "H265",
+#   "languages": ["MULTI"]
+#   ...
+# }
+
+# Calculate quality score
+score = get_quality_score(parsed)
+print(f"Quality Score: {score}")
+
+# Compare two releases
+rel_a = parse_filename("Gladiator.II.2024.1080p.BluRay.x264-GROUP")
+rel_b = parse_filename("Gladiator.II.2024.2160p.WEB-DL.x265-GROUP")
+
+if is_better_release(rel_b, rel_a):
+    print("Release B is better than Release A")
+```
+
+## Development & Tests
+
+### Setup Local Virtual Environment
+
+To set up the development environment, create a virtual environment and install the package in editable mode with development dependencies:
+
+```bash
+# Create the virtual environment
+virtualenv .venv
+
+# Activate the virtual environment
+source .venv/bin/activate
+
+# Install the package in editable/development mode
+pip install -e .[dev]
+```
+
+### Run Tests
+
+Run the test suite using `pytest`:
+
+```bash
+pytest tests/ -v
+```
+
+### Run Website Locally
+
+Due to browser CORS security policies, opening the HTML files directly as a local file (via `file://`) will block loading the relative Python files. You need to run a local web server from the repository root:
+
+```bash
+# Start a local HTTP server
+python3 -m http.server 8000
+```
+
+Then navigate to: [http://localhost:8000/](http://localhost:8000/) (which redirects to `/docs/`) or directly to [http://localhost:8000/docs/](http://localhost:8000/docs/).

releascenify-0.1.0/README.md

@@ -0,0 +1,80 @@
+# Releascenify
+
+A robust, regex-based Python library to parse scene release names and extract technical metadata (title, year, resolution, quality, codec, audio, languages, etc.).
+
+**Live Demo & Web Interface:** [https://dmachard.github.io/releascenify/docs/](https://dmachard.github.io/releascenify/docs/)
+
+## Why?
+Release names follow a strict grammar inherited from the Scene and P2P groups. Once decoded, you can predict the quality, source, language, and release group just from the filename. This library is a modernized alternative to PTN (Parse Torrent Name).
+
+## Installation
+*(To be published on PyPI)*
+
+## Usage
+
+```python
+from releascenify import parse_filename
+from releascenify.comparator import get_quality_score, is_better_release
+
+filename = "Gladiator.II.2024.MULTi.2160p.WEB-DL.DV.HDR.H265-GROUP"
+parsed = parse_filename(filename)
+
+print(parsed)
+# {
+#   "title": "Gladiator II",
+#   "year": 2024,
+#   "resolution": "2160P",
+#   "quality": "WEB-DL",
+#   "v_quality": "HDR DV",
+#   "codec": "H265",
+#   "languages": ["MULTI"]
+#   ...
+# }
+
+# Calculate quality score
+score = get_quality_score(parsed)
+print(f"Quality Score: {score}")
+
+# Compare two releases
+rel_a = parse_filename("Gladiator.II.2024.1080p.BluRay.x264-GROUP")
+rel_b = parse_filename("Gladiator.II.2024.2160p.WEB-DL.x265-GROUP")
+
+if is_better_release(rel_b, rel_a):
+    print("Release B is better than Release A")
+```
+
+## Development & Tests
+
+### Setup Local Virtual Environment
+
+To set up the development environment, create a virtual environment and install the package in editable mode with development dependencies:
+
+```bash
+# Create the virtual environment
+virtualenv .venv
+
+# Activate the virtual environment
+source .venv/bin/activate
+
+# Install the package in editable/development mode
+pip install -e .[dev]
+```
+
+### Run Tests
+
+Run the test suite using `pytest`:
+
+```bash
+pytest tests/ -v
+```
+
+### Run Website Locally
+
+Due to browser CORS security policies, opening the HTML files directly as a local file (via `file://`) will block loading the relative Python files. You need to run a local web server from the repository root:
+
+```bash
+# Start a local HTTP server
+python3 -m http.server 8000
+```
+
+Then navigate to: [http://localhost:8000/](http://localhost:8000/) (which redirects to `/docs/`) or directly to [http://localhost:8000/docs/](http://localhost:8000/docs/).

releascenify-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "releascenify"
+version = "0.1.0"
+description = "A regex-based Python library to parse scene release names and extract technical metadata"
+readme = "README.md"
+requires-python = ">=3.7"
+license = { file = "LICENSE" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+]
+
+[tool.setuptools]
+packages = ["releascenify"]

releascenify-0.1.0/releascenify/__init__.py

@@ -0,0 +1,4 @@
+from .parser import ReleaseParser, parse_filename
+from .comparator import get_quality_score, is_better_release
+
+__all__ = ['ReleaseParser', 'parse_filename', 'get_quality_score', 'is_better_release']

releascenify-0.1.0/releascenify/comparator.py

@@ -0,0 +1,56 @@
+from typing import Dict, Any
+
+def get_quality_score(parsed_release: Dict[str, Any]) -> int:
+    """
+    Returns a numeric score for quality comparison.
+    Higher score means better quality.
+    Scoring priority: Resolution > Language > Video Quality > Audio > Source > Codec
+    """
+    score = 0
+    
+    # 1. Resolution
+    res = (parsed_release.get("resolution") or "").lower()
+    # Assuming 4K is best, then 4KLIGHT, 1080p, 720p, 480p
+    # Note: DDLtower logic penalizes 4KLight vs True 4K. 
+    # True 4K: 450, 4KLight: 400 (or vice versa depending on preference, here we stick to generic)
+    if "4klight" in res: score += 400
+    elif "2160" in res or "4k" in res: score += 450
+    elif "1080" in res: score += 300
+    elif "720" in res: score += 200
+    elif "480" in res: score += 100
+    
+    # 2. Language (Multi > VF > VOSTFR)
+    langs = [l.lower() for l in parsed_release.get("languages", [])]
+    if "multi" in langs: score += 50
+    elif "french" in langs or "vf" in langs: score += 30
+    elif "vostfr" in langs: score += 10
+    
+    # 3. Video Quality (DV / HDR / 10bit)
+    vq = (parsed_release.get("v_quality") or "").lower()
+    if "dv" in vq or "dovi" in vq: score += 25
+    if "hdr" in vq: score += 20
+    if "10bit" in vq: score += 10
+    
+    # 4. Audio Quality (Atmos / TrueHD > DTS > AC3)
+    aud = (parsed_release.get("audio") or "").lower()
+    if "atmos" in aud or "truehd" in aud: score += 15
+    elif "dts" in aud: score += 10
+    elif "ac3" in aud or "ddp" in aud: score += 5
+
+    # 5. Source Quality (BluRay > WEB-DL > HDTV)
+    q = (parsed_release.get("quality") or "").lower()
+    if "bluray" in q or "bdrip" in q: score += 10
+    elif "web" in q: score += 7
+    elif "hdtv" in q: score += 3
+    
+    # 6. Codec (HEVC / x265 > x264)
+    c = (parsed_release.get("codec") or "").lower()
+    if "265" in c or "hevc" in c: score += 5
+    
+    return score
+
+def is_better_release(release_a: Dict[str, Any], release_b: Dict[str, Any]) -> bool:
+    """
+    Returns True if release_a is considered better than release_b.
+    """
+    return get_quality_score(release_a) > get_quality_score(release_b)

releascenify-0.1.0/releascenify/parser.py

@@ -0,0 +1,135 @@
+import re
+import html
+import unicodedata
+from typing import Dict, Any, Optional, List
+
+class ReleaseParser:
+    def __init__(self):
+        # Base patterns to extract common release info
+        self.patterns = {
+            'season': r'(?i)\b(?:s|saison)[\.\-\s]*(\d{1,2})\b',
+            'episode': r'(?i)\b(?:e|ep|episode)[\.\-\s]*(\d{1,3})\b',
+            'year': r'\b(19\d{2}|20[0-2]\d)\b',
+            'resolution': r'(?i)(4KLIGHT|4K|2160[pP]|1080[pP]|720[pP]|UHD)',
+            'quality': r'(?i)(WEB-DL|WEBRIP|WEBLIGHT|WEB|BLURAY|BDRIP|BRRIP|DVDRIP|HDTV)',
+            'codec': r'(?i)(x265|x264|h265|h264|HEVC)',
+            'audio': r'(?i)(AAC|AC3|E-AC3|DTS-HD|DTS|ATMOS|TRUEHD|DDP\d\.\d)',
+            'channels': r'(7\.1|5\.1|2\.0)\b',
+        }
+        
+    def clean_network_name(self, name: str) -> str:
+        """Normalizes network names for better UI display."""
+        if not name: return name
+        mapping = {
+            "Disney Plus": "Disney+", "Amazon Studios": "Amazon", "Amazon Prime": "Amazon",
+            "HBO Max": "HBO", "Apple TV Plus": "Apple TV+", "Paramount Plus": "Paramount+"
+        }
+        return mapping.get(name, name)
+
+    def extract_v_quality(self, filename: str) -> Optional[str]:
+        """Detects HDR, DV, etc. from filename."""
+        if not filename: return None
+        fn = filename.upper()
+        tags = []
+        if any(x in fn for x in ["DV", "DOVI"]) or re.search(r'DOLBY[\.\-\s]VISION', fn): tags.append("DV")
+        if any(x in fn for x in ["HDR", "HDR10", "HDR10PLUS", "HDR10+"]): tags.append("HDR")
+        if "HLG" in fn: tags.append("HLG")
+        return " ".join(sorted(list(set(tags)), reverse=True)) if tags else None
+
+    def _extract_langs(self, fn_up: str) -> List[str]:
+        langs = []
+        if "TRUEFRENCH" in fn_up or "VFF" in fn_up or "FRENCH" in fn_up: langs.append("FRENCH")
+        if "MULTI" in fn_up: langs.append("MULTI")
+        if "VOSTFR" in fn_up or "VOST" in fn_up: langs.append("VOSTFR")
+        if "VFI" in fn_up or "VFQ" in fn_up or "VF2" in fn_up or re.search(r'\bVF\b', fn_up.replace('.', ' ').replace('-', ' ').replace('_', ' ')): langs.append("VF")
+        return list(dict.fromkeys(langs))
+
+    def parse(self, filename: str) -> Dict[str, Any]:
+        if not filename: return {}
+        
+        result = {
+            "title": "", "category": "movie", "year": None, "season": None, "episode": None,
+            "resolution": None, "quality": None, "codec": None, "audio": None, 
+            "channels": None, "network": "", "v_quality": "", "languages": [], "group": None
+        }
+        
+        # Extract group
+        group_match = re.search(r'-([A-Za-z0-9_@]+)(?:\s*\(.*?\))?(?:\.[a-z0-9]{3,4})?$', filename.strip())
+        if group_match:
+            grp = group_match.group(1)
+            if grp.upper() not in ['DL', 'HDMA', 'FR', 'EN', 'HD']:
+                result['group'] = grp
+        
+        # Check for joint SxxExx
+        se_match = re.search(r'(?i)\bs(\d{1,2})[\.\-\s]?[ex](\d{1,3})\b', filename)
+        if se_match:
+            result['season'] = str(int(se_match.group(1)))
+            result['episode'] = str(int(se_match.group(2)))
+        else:
+            # Check individual fallbacks
+            s_match = re.search(self.patterns['season'], filename)
+            if s_match: result['season'] = str(int(s_match.group(1)))
+            e_match = re.search(self.patterns['episode'], filename)
+            if e_match: result['episode'] = str(int(e_match.group(1)))
+
+        # Extract basic info using regex (except audio and year, handled below)
+        for key, pattern in self.patterns.items():
+            if key in ['season', 'episode', 'audio', 'year']: continue # Already handled
+            match = re.search(pattern, filename)
+            if match:
+                result[key] = match.group(1).upper()
+
+        # Extract year (prefer the last matching year if multiple are present, e.g., 1917 (2019))
+        years = re.findall(self.patterns['year'], filename)
+        if years:
+            result['year'] = int(years[-1])
+
+        # Extract audio with priority (Atmos/TrueHD > DTS > AC3/DDP/AAC)
+        for pat in [r'(?i)(ATMOS|TRUEHD)', r'(?i)(DTS-HD|DTS)', r'(?i)(E-AC3|AC3|AAC|DDP\d\.\d|DDP)']:
+            match = re.search(pat, filename)
+            if match:
+                result['audio'] = match.group(1).upper()
+                break
+
+        if result['season'] or result['episode']:
+            result['category'] = 'series'
+            
+        # V_Quality
+        result['v_quality'] = self.extract_v_quality(filename) or ""
+        
+        # Clean title
+        fn_clean = html.unescape(filename)
+        fn_clean = unicodedata.normalize('NFKD', fn_clean).encode('ASCII', 'ignore').decode('utf-8')
+        
+        # Remove Volume/Part markers
+        fn_clean = re.sub(r'\b(Vol|Pt|Part|Partie)[\.\s]?\d+\b', ' ', fn_clean, flags=re.I)
+        fn_clean = re.sub(r'\b\d+(?:e|ème|re|nd|rd|th)?\s+partie\b', ' ', fn_clean, flags=re.I)
+        
+        # Split point for title
+        tags_to_split = [
+            r'S\d+', r'E\d+', r'S\d+E\d+', r'SAISON[\.\-\s]?\d+', r'EPISODE[\.\-\s]?\d+', 'MULTI', 'FRENCH', 'TRUEFRENCH', 'VOSTFR', 'SUBFRENCH', 'VFF', 'VFI', 'VFQ', 'VOST', 'STFI',
+            '1080P', '720P', '2160P', '4K', '4KLIGHT', 'UHD', 'BLURAY', 'BDRIP', 'DVDRIP', 'WEBRIP', 'WEB-DL', 'WEBLIGHT', 'WEB',
+            'HDR', 'DV', 'HEVC', 'X264', 'X265', 'H264', 'H265', 'REPACK', 'PROPER', 'FINAL', 'INTERNAL', 'CUSTOM', 'AC3', 'DDP', 'DTS', 'ATMOS',
+            r'19\d{2}', r'20[0-2]\d'
+        ]
+        pattern = r'[\.\[\(\s\-\_](?:' + '|'.join(tags_to_split) + r')\b'
+        title = re.split(pattern, fn_clean, flags=re.I)[0]
+        
+        title = title.replace('.', ' ').replace('_', ' ').strip()
+        title = re.sub(r'\s+', ' ', title).strip()
+        
+        result['title'] = title
+        
+        # Languages
+        fn_up = filename.upper().replace('[', '.').replace(']', '.').replace('_', '.')
+        result['languages'] = self._extract_langs(fn_up)
+        
+        # Fix resolution for 4KLIGHT
+        if "4KLIGHT" in fn_up:
+            result['resolution'] = "4KLIGHT"
+
+        return result
+
+def parse_filename(filename: str) -> Dict[str, Any]:
+    parser = ReleaseParser()
+    return parser.parse(filename)

releascenify-0.1.0/releascenify.egg-info/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: releascenify
+Version: 0.1.0
+Summary: A regex-based Python library to parse scene release names and extract technical metadata
+License: MIT License
+        
+        Copyright (c) 2026 Denis Machard
+        
+        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.
+        
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Dynamic: license-file
+
+# Releascenify
+
+A robust, regex-based Python library to parse scene release names and extract technical metadata (title, year, resolution, quality, codec, audio, languages, etc.).
+
+**Live Demo & Web Interface:** [https://dmachard.github.io/releascenify/docs/](https://dmachard.github.io/releascenify/docs/)
+
+## Why?
+Release names follow a strict grammar inherited from the Scene and P2P groups. Once decoded, you can predict the quality, source, language, and release group just from the filename. This library is a modernized alternative to PTN (Parse Torrent Name).
+
+## Installation
+*(To be published on PyPI)*
+
+## Usage
+
+```python
+from releascenify import parse_filename
+from releascenify.comparator import get_quality_score, is_better_release
+
+filename = "Gladiator.II.2024.MULTi.2160p.WEB-DL.DV.HDR.H265-GROUP"
+parsed = parse_filename(filename)
+
+print(parsed)
+# {
+#   "title": "Gladiator II",
+#   "year": 2024,
+#   "resolution": "2160P",
+#   "quality": "WEB-DL",
+#   "v_quality": "HDR DV",
+#   "codec": "H265",
+#   "languages": ["MULTI"]
+#   ...
+# }
+
+# Calculate quality score
+score = get_quality_score(parsed)
+print(f"Quality Score: {score}")
+
+# Compare two releases
+rel_a = parse_filename("Gladiator.II.2024.1080p.BluRay.x264-GROUP")
+rel_b = parse_filename("Gladiator.II.2024.2160p.WEB-DL.x265-GROUP")
+
+if is_better_release(rel_b, rel_a):
+    print("Release B is better than Release A")
+```
+
+## Development & Tests
+
+### Setup Local Virtual Environment
+
+To set up the development environment, create a virtual environment and install the package in editable mode with development dependencies:
+
+```bash
+# Create the virtual environment
+virtualenv .venv
+
+# Activate the virtual environment
+source .venv/bin/activate
+
+# Install the package in editable/development mode
+pip install -e .[dev]
+```
+
+### Run Tests
+
+Run the test suite using `pytest`:
+
+```bash
+pytest tests/ -v
+```
+
+### Run Website Locally
+
+Due to browser CORS security policies, opening the HTML files directly as a local file (via `file://`) will block loading the relative Python files. You need to run a local web server from the repository root:
+
+```bash
+# Start a local HTTP server
+python3 -m http.server 8000
+```
+
+Then navigate to: [http://localhost:8000/](http://localhost:8000/) (which redirects to `/docs/`) or directly to [http://localhost:8000/docs/](http://localhost:8000/docs/).

releascenify-0.1.0/releascenify.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+releascenify/__init__.py
+releascenify/comparator.py
+releascenify/parser.py
+releascenify.egg-info/PKG-INFO
+releascenify.egg-info/SOURCES.txt
+releascenify.egg-info/dependency_links.txt
+releascenify.egg-info/requires.txt
+releascenify.egg-info/top_level.txt
+tests/test_parser.py

releascenify-0.1.0/releascenify.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

releascenify-0.1.0/releascenify.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+pytest>=7.0.0

releascenify-0.1.0/releascenify.egg-info/top_level.txt

@@ -0,0 +1 @@
+releascenify

releascenify-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

releascenify-0.1.0/tests/test_parser.py

@@ -0,0 +1,37 @@
+import json
+import os
+import pytest
+from releascenify.parser import parse_filename
+
+def load_test_cases(category):
+    filename = f'test_cases_{category}.json'
+    cases_file = os.path.join(os.path.dirname(__file__), filename)
+    with open(cases_file, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    
+    cases = []
+    for case in data:
+        # Use filename as ID for nice pytest output
+        cases.append(pytest.param(case['filename'], case['expected'], id=case['filename']))
+    return cases
+
+def run_parse_test(filename, expected):
+    result = parse_filename(filename)
+    for key, expected_val in expected.items():
+        actual_val = result.get(key)
+        if isinstance(expected_val, list):
+            # Sort lists for comparison (like languages)
+            assert sorted(actual_val) == sorted(expected_val), f"Failed on '{filename}': expected {key}={expected_val}, got {actual_val}"
+        else:
+            assert actual_val == expected_val, f"Failed on '{filename}': expected {key}={expected_val}, got {actual_val}"
+
+@pytest.mark.parametrize("filename,expected", load_test_cases('movies'))
+def test_movie_parser(filename, expected):
+    run_parse_test(filename, expected)
+
+@pytest.mark.parametrize("filename,expected", load_test_cases('series'))
+def test_series_parser(filename, expected):
+    run_parse_test(filename, expected)
+
+if __name__ == '__main__':
+    pytest.main([__file__, '-v'])