Unit3Dup 0.9.10__tar.gz → 0.9.12__tar.gz

{unit3dup-0.9.10 → unit3dup-0.9.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Unit3Dup
-Version: 0.9.10
+Version: 0.9.12
 Summary: An uploader for the Unit3D torrent tracker
 Author: Parzival
 License-Expression: MIT

{unit3dup-0.9.10 → unit3dup-0.9.12}/Unit3Dup.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Unit3Dup
-Version: 0.9.10
+Version: 0.9.12
 Summary: An uploader for the Unit3D torrent tracker
 Author: Parzival
 License-Expression: MIT

{unit3dup-0.9.10 → unit3dup-0.9.12}/Unit3Dup.egg-info/SOURCES.txt

@@ -18,8 +18,8 @@ common/extractor.py
 common/frames.py
 common/mediainfo.py
 common/mediainfo_string.py
-common/p2p_tags.py
 common/settings.py
+common/tags.py
 common/title.py
 common/torrent_clients.py
 common/utility.py

{unit3dup-0.9.10 → unit3dup-0.9.12}/common/command.py

@@ -27,6 +27,7 @@ class CommandLine:
         parser.add_argument("-u", "--upload", type=str, help="Upload path")
         parser.add_argument("-f", "--folder", type=str, help="Upload folder")
         parser.add_argument("-scan", "--scan", type=str, help="Scan folder")
+        parser.add_argument("-b", "--buildtags", action="store_true", help="Auto build torrent name")
 
         parser.add_argument("-reseed", "--reseed", action="store_true", help="reseed folder")
         parser.add_argument("-gentitle", "--gentitle", action="store_true", help="")
@@ -40,19 +41,19 @@ class CommandLine:
         parser.add_argument('-force', nargs='?', const="movie", type=str, default=None)
         parser.add_argument("-noseed", "--noseed", action="store_true", help="No seeding after upload")
         parser.add_argument("-noup", "--noup", action="store_true", help="Torrent only. No upload")
-        parser.add_argument("-duplicate", "--duplicate", action="store_true", help="Find duplicates")
+        parser.add_argument("-dup", "--duplicate", action="store_true", help="Find duplicates")
         parser.add_argument("-personal", "--personal", action="store_true", help="Set to personal release")
 
         parser.add_argument("-ftp", "--ftp", action="store_true", help="Connect to FTP")
 
         # optional
-        parser.add_argument("-dump", "--dump", action="store_true", help="Download all torrent titles")
-        parser.add_argument("-s", "--search", type=str, help="Search for torrent")
+        parser.add_argument("-dmp", "--dump", action="store_true", help="Download all torrent titles")
+        parser.add_argument("-sch", "--search", type=str, help="Search for torrent")
         parser.add_argument("-db", "--dbsave", action="store_true", help="Save the search results")
         parser.add_argument("-i", "--info", type=str, help="Get info on torrent")
         parser.add_argument("-up", "--uploader", type=str, help="Search by uploader")
-        parser.add_argument("-desc", "--description", type=str, help="Search by description")
-        parser.add_argument("-bdinfo", "--bdinfo", type=str, help="Show BDInfo")
+        parser.add_argument("-d", "--description", type=str, help="Search by description")
+        parser.add_argument("-bd", "--bdinfo", type=str, help="Show BDInfo")
         parser.add_argument("-m", "--mediainfo", type=str, help="Show MediaInfo")
         parser.add_argument("-st", "--startyear", type=str, help="Start year")
         parser.add_argument("-en", "--endyear", type=str, help="End year")
@@ -68,8 +69,8 @@ class CommandLine:
         parser.add_argument("-playid", "--playlist_id", type=str, help="Playlist ID")
         parser.add_argument("-coll", "--collection_id", type=str, help="Collection ID")
         parser.add_argument("-free", "--freelech", type=str, help="Freelech discount")
-        parser.add_argument("-a", "--alive", action="store_true", help="Alive torrent")
-        parser.add_argument("-d", "--dead", action="store_true", help="Dead torrent")
+        parser.add_argument("-al", "--alive", action="store_true", help="Alive torrent")
+        parser.add_argument("-dd", "--dead", action="store_true", help="Dead torrent")
         parser.add_argument("-dy", "--dying", action="store_true", help="Dying torrent")
 
         parser.add_argument(

{unit3dup-0.9.10 → unit3dup-0.9.12}/common/settings.py

@@ -15,7 +15,7 @@ from common.utility import ManageTitles
 from common import trackers
 
 config_file = "Unit3Dbot.json"
-version = "0.9.10"
+version = "0.9.12"
 
 if os.name == "nt":
     WATCHER_DESTINATION_PATH: Path = Path(os.getenv("LOCALAPPDATA", ".")) / "Unit3Dup_config" / "watcher_destination_path"
@@ -250,12 +250,13 @@ class Validate:
             print(f"-> Invalid TAG position. The list is empty !")
             exit(1)
 
-        if len(position_list) != 9:
+        if len(position_list) > 17 or len(position_list) < 5:
             print(f"-> Invalid TAG position list. Wrong number of elements !")
             exit(1)
 
         for tag in position_list:
-            if tag.lower() not in ["version","resolution", "platform","source", "audio", "channels", "flag", "subtitle", "video"]:
+            if tag.lower() not in ["title", "year", "season", "version", "resolution", "uhd", "platform", "source", "remux",
+                                   "multi", "acodec", "channels", "flag", "subtitle", "vcodec", "hdr", "video_encoder"]:
                 print(f"-> Invalid TAG position '{tag}'. Please fix your configuration file")
                 exit(1)
 
@@ -578,7 +579,8 @@ class Load:
                 "PASSIMA_PRIORITY": 5,
                 "IMARIDE_PRIORITY": 6,
                 "NUMBER_OF_SCREENSHOTS": 4,
-                "TAGS_POSITION": ["version","resolution", "platform", "source", "audio", "channels", "flag", "subtitle", "video"],
+                "TAGS_POSITION": ["title", "year", "season", "version", "resolution", "uhd", "platform", "source", "remux",
+                                  "multi", "acodec", "channels", "flag", "subtitle", "vcodec", "hdr", "video_encoder"],
                 "YOUTUBE_FAV_CHANNEL_ID": "UCGCbxpnt25hWPFLSbvwfg_w",
                 "YOUTUBE_CHANNEL_ENABLE": "False",
                 "DUPLICATE_ON": "true",

unit3dup-0.9.12/common/tags.py

@@ -0,0 +1,357 @@
+# -*- coding: utf-8 -*-
+import os
+import re
+from common.mediainfo import MediaFile
+from common.utility import ManageTitles
+
+TAG_TYPES = {
+    "REMUX": "remux",
+    "WEB-DL": "source",
+    "WEB-DLMUX": "source",
+    "WEBMUX": "source",
+    "WEBRIP": "source",
+    "BD-UNTOUCHED": "source",
+    "TS": "source",
+    "CAM": "source",
+    "HDTS": "source",
+    "MD": "source",
+    "UHDRIP": "source",
+    "BLURAY": "source",
+    "BRRIP": "source",
+    "BDRIP": "source",
+    "FHDRIP": "source",
+
+    "ATVP": "platform",
+    "AMZN": "platform",
+    "AMC": "platform",
+    "CN": "platform",
+    "CR": "platform",
+    "DCU": "platform",
+    "DISC": "platform",
+    "DSCP": "platform",
+    "DSNY": "platform",
+    "DSNP": "platform",
+    "DPLY": "platform",
+    "ESPN": "platform",
+    "FOOD": "platform",
+    "FOX": "platform",
+    "PLAY": "platform",
+    "HBO": "platform",
+    "HMAX": "platform",
+    "HGTV": "platform",
+    "HIST": "platform",
+    "HULU": "platform",
+    "MTOD": "platform",
+    "NATG": "platform",
+    "NF": "platform",
+    "NICK": "platform",
+    "NOW": "platform",
+    "PMNT": "platform",
+    "PMTP": "platform",
+    "PCOK": "platform",
+    "RKTN": "platform",
+    "SHO": "platform",
+    "SKST": "platform",
+    "STAN": "platform",
+    "STRP": "platform",
+    "STZ": "platform",
+    "TIMV": "platform",
+
+    "REPACK": "version",
+    "EXTENDED": "version",
+    "SUBBED": "version",
+    "MUX": "version",
+    "REMASTERED": "version",
+    "READNFO": "version",
+    "UNRATED": "version",
+    "LIMITED": "version",
+    "VU": "version",
+    "STV": "version",
+    "RECODE": "version",
+    "INTERNAL": "version",
+    "PROPER": "version",
+    "DUAL": "version",
+    "UNTOUCHED": "version",
+    "COMPLETE": "version",
+    "COMPLETA": "version",
+
+    "X264": "video_encoder",
+    "X265": "video_encoder",
+}
+
+# From hdr format
+hdr_map = {
+    "DOLBY VISION": "DV",
+    "DOLBY VISION HDR": "DV HDR",
+    "DOLBY VISION HDR10": "DV HDR10",
+    "HDR10PLUS": "HDR10+",
+    "HDRPLUS+": "HDR10+",
+    "HDR10+": "HDR10+",
+    "HDR10": "HDR10",
+    "HDR10 / HDR10": "HDR10",
+    "DOVI": "DV",
+    "HDR": "HDR",
+}
+
+audio_translate = {
+    "AC3": "DD",
+    "AAC LC": "AAC",
+    "AC-3": "DD",
+    "EAC3": "DD+",
+    "E-AC3": "DD+",
+    "E-AC-3": "DD+",
+    "E-AC-3 JOC": "DD+",
+    "DTS": "DTS",
+    "DTS ES": "DTS-ES",
+    "DTS ES XLL": "DTS-HD MA",
+    "DTS XLL": "DTS-HD MA",
+    "MLP FBA 16-ch": "TrueHD",
+    "MPEG Audio": "MPEG",
+}
+
+video_translate = {
+    "AVC": "H.264",
+    "HEVC": "H.265",
+    "H265": "H.265",
+    "H264": "H.264",
+}
+
+video_encoder_translate = {
+    "X265": "x.265",
+    "X264": "x.264",
+}
+
+
+class SearchTags(object):
+    def __init__(self, filename, title: str, year: str, season: int, episode: int,
+                 mediafile: MediaFile, tags_position: list, releaser_sign: str):
+
+        self.tags_position = tags_position
+        self.releaser_sign = releaser_sign
+        self.mediafile = mediafile
+        self.filename = filename
+        self.episode = episode
+        self.season = season
+        self.title = title
+        self.year = year
+        self.tags_dict = {}
+        self.tags_position = tags_position
+
+    def normalize_version_tag(self, tag: str) -> str:
+        tag_esc = re.escape(tag)
+        # Filter hyphenated,space compounds
+        tag_esc = tag_esc.replace(r'\ ', r'[.\s_-]*')
+        return tag_esc
+
+    def normalize_platform_tag(self, tag: str) -> str:
+        # escape
+        tag_esc = re.escape(tag)
+        return tag_esc
+
+    def normalize_sources(self, tag: str) -> str:
+        tag_esc = re.escape(tag)
+        # Filter hyphenated,space compounds
+        tag_esc = tag_esc.replace(r'\ ', r'[.\s_-]*')
+        return tag_esc
+
+    def normalize_video_encoder(self, tag: str) -> str:
+        tag_esc = re.escape(tag)
+        tag_esc = re.sub(r'([A-Z])(\d+)', r'\1[._-]?\2', tag_esc)
+        return tag_esc
+
+    def process(self) -> str:
+        patterns = []
+
+        # loop sorted TAG_TYPES dictionary
+        for i, (tag, category) in enumerate(
+                sorted(TAG_TYPES.items(), key=lambda x: len(x[0]), reverse=True)
+        ):
+            if category == "version":
+                norm = self.normalize_version_tag(tag)
+            elif category == "platform":
+                norm = self.normalize_platform_tag(tag)
+            elif category == "source":
+                norm = self.normalize_sources(tag)
+            elif category == "video_encoder":
+                norm = self.normalize_video_encoder(tag)
+            else:
+                norm = re.escape(tag)
+                # Save a regex pattern for each category
+            patterns.append([norm, category])
+
+        # Run regex
+        for p, category in patterns:
+            regex = re.compile(r'(?<!\w)' + p + r'(?!\w)', re.IGNORECASE)
+            matches = regex.findall(self.filename)
+            if matches:
+                self.tags_dict.setdefault(category, []).append(matches[0])
+
+        # /// Read from mediainfo
+        updated_category = {}
+        for category in self.tags_position:
+            if category == "acodec":
+                updated_category = self.mediainfo_audio(category=category)
+
+            elif category == "vcodec":
+                updated_category = self.mediainfo_video(category=category)
+
+            elif category == "hdr":
+                updated_category = self.mediainfo_hdr(category=category)
+
+            elif category == "uhd":
+                updated_category = self.mediainfo_uhd(category=category)
+
+            elif category == "subtitle":
+                updated_category = {'subtitle': "SUBS" if len(self.mediafile.subtitle_track) > 1 else "SUB"}
+
+            if updated_category:
+                self.tags_dict.update(updated_category)
+
+        # /// Add S#E#, title, Year
+        se_str = ''
+        if self.season is not None and self.episode is not None:
+            se_str = f"S{self.season:02d}E{self.episode:02d}"
+        elif self.season is not None:
+            se_str = f"S{self.season:02d}"
+        elif self.episode is not None:
+            se_str = f"E{self.episode:02d}"
+
+        self.tags_dict.update({'title': self.title})
+        if self.year:
+            self.tags_dict.update({'year': self.year})
+        if se_str:
+            self.tags_dict.update({'season': se_str})
+
+        # /// Add Sign
+        if not self.releaser_sign:
+            filename, _ = os.path.splitext(os.path.basename(self.filename))
+            m = re.search(r'-([A-Za-z0-9]+)$', filename)
+            self.releaser_sign = f"-{m.group(1)}" if m and m.group(1) not in TAG_TYPES else ""
+        else:
+            self.releaser_sign = f"-{self.releaser_sign}"
+
+        # /// Order according to tag position
+        tags_dict = {
+            k: self.tags_dict[k]
+            for k in self.tags_position
+            if k in self.tags_dict
+        }
+
+        # /// Build the title
+        build = []
+        for k, v in tags_dict.items():
+            if isinstance(v, list):
+                build.append(' '.join(v))
+            else:
+                build.append(str(v))
+
+        refactored = ' '.join(build) + self.releaser_sign
+        return refactored
+
+    def mediainfo_audio(self, category: str) -> dict:
+        langs = set()
+        audio_codecs = []
+        if self.mediafile.audio_track:
+            for audio in self.mediafile.audio_track:
+                other_format = audio.get('other_format', [])
+                if other_format:
+                    codec_translated = audio_translate.get(other_format[0], '')
+                    if not codec_translated:
+                        codec_translated = other_format[0]
+                    # Check Atmos
+                    dolby = audio.get('commercial_name', "").lower()
+                    atmos = 'Atmos' if 'atmos' in dolby else ''
+                    # Add audio codec
+                    channel_s = audio.get('channel_s', 0)
+                    # Add channels
+                    ch = {2: "2.0", 6: "5.1", 8: "7.1"}.get(channel_s, "")
+                    if f"{codec_translated} {ch} {atmos}".strip() not in audio_codecs:
+                        audio_codecs.append(f"{codec_translated} {ch} {atmos}".strip())
+                    print(f"Mediainfo {other_format} -> {codec_translated} {ch} {atmos}")
+
+                # Add flags
+                for l in audio.get('other_language', []):
+                    c = ManageTitles.convert_iso(l)
+                    if c:
+                        if isinstance(c, list):
+                            langs.update(c)
+                        else:
+                            langs.add(c)
+                        break
+                # Add multilanguage tag when languages > 2
+                if len(langs) > 2:
+                    self.tags_dict.update({'multi': 'MULTI'})
+
+            audio_codecs.extend(list(langs))
+        return {category: audio_codecs}
+
+    def mediainfo_video(self, category: str) -> dict:
+        codec_translated = {}
+        if self.mediafile.video_track:
+            for video in self.mediafile.video_track:
+                video_format = video.get('format', "")
+                codec_translated = video_translate.get(video_format, video_format)
+        if codec_translated:
+            return {category: codec_translated}
+        return codec_translated
+
+    def mediainfo_hdr(self, category: str) -> dict:
+        if self.mediafile.video_track:
+            for video in self.mediafile.video_track:
+                hdr_format_commercial = video.get('hdr_format_commercial', "")
+                hdr_format = video.get('hdr_format', "")
+                # Check hdr
+                if hdr_format_commercial:
+                    print(f"hdr_format_commercial: {hdr_format_commercial}")
+                    print(f"hdr_format: {hdr_format}")
+                    hdr = ''
+                    if hdr_format_commercial in hdr_map:
+                        print(f"hdr_format_commercial: {hdr_format_commercial} -> Tag: {hdr_map[hdr_format_commercial]}")
+                        hdr = hdr_map[hdr_format_commercial]
+                        # Check dolby vision
+                    if 'DOLBY VISION' in hdr_format_commercial.upper() or 'DOLBY VISION' in hdr_format.upper():
+                        hdr = f"DOLBY VISION {hdr}"
+                        print(hdr)
+                    return {category: hdr_map[hdr]}
+        return {}
+
+    def mediainfo_uhd(self, category: str) -> dict:
+        """
+        identify resolution based on Height and Width tolerance 5%
+        """
+        result = {}
+        if self.mediafile.video_track:
+            video_height = int(self.mediafile.video_track[0].get('height', 0))
+            video_width = int(self.mediafile.video_track[0].get('width', 0))
+            print(f"VideoTrack : W{video_width} x H{video_height}")
+
+            # Calculate range 5%
+            def in_range(value, standard):
+                tol = standard * 0.05
+                return standard - tol <= value <= standard + tol
+
+            # /// UHD
+            if video_height >= 2000 or video_width >= 3840:
+                result[category] = 'UHD'
+                result['resolution'] = '2160p'
+            # /// Full HD
+            elif in_range(video_height, 1080) or in_range(video_width, 1920):
+                result[category] = 'FullHD'
+                result['resolution'] = '1080p'
+            # /// HD
+            elif in_range(video_height, 720) or in_range(video_width, 1280):
+                result[category] = 'HD'
+                result['resolution'] = '720p'
+            # /// SD 576p
+            elif in_range(video_height, 576) or in_range(video_width, 768):
+                result[category] = 'SD'
+                result['resolution'] = '576p'
+            # /// SD 480p
+            elif in_range(video_height, 480) or in_range(video_width, 640):
+                result[category] = 'SD'
+                result['resolution'] = '480p'
+            else:
+                result[category] = 'unknown'
+                result['resolution'] = f'{video_width}x{video_height}'
+
+        return result

{unit3dup-0.9.10 → unit3dup-0.9.12}/common/utility.py

@@ -171,8 +171,39 @@ class ManageTitles:
 
         return filename
 
+    @staticmethod
+    def recover_tag(filename_sanitized: str) -> str:
+
+        # Add the tag
+        replacements = [
+            (r'\b7 \b1\b', '7.1'),
+            (r'\b5 \b1\b', '5.1'),
+            (r'\bDDP5 \b1\b', 'DDP5.1'),
+            (r'\bDDP2 \b0\b', 'DDP2.0'),
+            (r'\bDD5 \b1\b', 'DD5.1'),
+            (r'\bDD2 \b0\b', 'DD2.0'),
+            (r'\b2 \b0\b', '2.0'),
+            (r'\bWEB \bDL\b', 'WEB-DL'),
+            (r'\bWEB \bDLMUX\b', 'WEB-DLMUX'),
+            (r'\bBD \bUNTOUCHED\b', 'BD-UNTOUCHED'),
+            (r'\bCINEMA \bMD\b', 'CINEMA-MD'),
+            (r'\bHEVC \bFHC\b', 'HEVC-FHC'),
+            (r'\bCBR \bCBZ\b', 'CBR-CBZ'),
+            (r'\bH \b264\b', 'H.264'),
+            (r'\bH \b265\b', 'H.265'),
+            (r'\bAAC2 \b0\b', 'AAC2.0'),
+            (r'\bAAC5 \b1\b', 'AAC5.1'),
+        ]
+
+        for tag, replacement in replacements:
+            filename_sanitized = re.sub(tag, replacement, filename_sanitized, flags=re.IGNORECASE)
+        return filename_sanitized
+
     @staticmethod
     def clean_text(filename: str) -> str:
+        """
+            Clean filename
+        """
 
         # Remove each addition from the string
         filename_sanitized = filename
@@ -193,34 +224,23 @@ class ManageTitles:
 
         # remove double space
         filename_sanitized = re.sub(r"\s+", " ", filename_sanitized).strip()
-
         return filename_sanitized
 
     @staticmethod
-    def recover_tag(filename_sanitized: str) -> str:
+    def clean_tags(filename: str) -> str:
+        """
+            Clean filename for title generation
+        """
 
-        # Add the tag
-        replacements = [
-            (r'\b7 \b1\b', '7.1'),
-            (r'\b5 \b1\b', '5.1'),
-            (r'\bDDP5 \b1\b', 'DDP5.1'),
-            (r'\bDDP2 \b0\b', 'DDP2.0'),
-            (r'\bDD5 \b1\b', 'DD5.1'),
-            (r'\bDD2 \b0\b', 'DD2.0'),
-            (r'\b2 \b0\b', '2.0'),
-            (r'\bWEB \bDL\b', 'WEB-DL'),
-            (r'\bWEB \bDLMUX\b', 'WEB-DLMUX'),
-            (r'\bBD \bUNTOUCHED\b', 'BD-UNTOUCHED'),
-            (r'\bCINEMA \bMD\b', 'CINEMA-MD'),
-            (r'\bHEVC \bFHC\b', 'HEVC-FHC'),
-            (r'\bCBR \bCBZ\b', 'CBR-CBZ'),
-            (r'\bH \b264\b', 'H.264'),
-            (r'\bH \b265\b', 'H.265'),
-            (r'\bAAC2 \b0\b', 'AAC2.0'),
-        ]
+        filename_sanitized = filename
+        # Remove v version
+        filename_sanitized = re.sub(r"v\d+(?:[ .]\d+)*", "", filename_sanitized).strip()
 
-        for tag, replacement in replacements:
-            filename_sanitized = re.sub(tag, replacement, filename_sanitized, flags=re.IGNORECASE)
+        # remove spaces, tab, newline
+        filename_sanitized = re.sub(r"\s+", " ", filename_sanitized)
+
+        # remove double space
+        filename_sanitized = re.sub(r"\s+", " ", filename_sanitized).strip()
         return filename_sanitized
 
 

{unit3dup-0.9.10 → unit3dup-0.9.12}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 dynamic = ["dependencies"]
 name = "Unit3Dup"
-version = "0.9.10"
+version = "0.9.12"
 description = "An uploader for the Unit3D torrent tracker"
 readme = "README.rst"
 requires-python = ">=3.10"

{unit3dup-0.9.10 → unit3dup-0.9.12}/unit3dup/media.py

@@ -6,9 +6,7 @@ from common.external_services.igdb.core.tags import crew_patterns, platform_patt
 from common.title import Guessit
 from common.utility import ManageTitles, System
 from common.mediainfo import MediaFile
-from common.p2p_tags import P2pTags
 from common import title
-from unit3dup import config_settings
 from view import custom_console
 
 
@@ -62,9 +60,12 @@ class Media:
             self._title_sanitized = ManageTitles.clean_text(self.title)
         return self._title_sanitized
 
-    @title_sanitized.setter
-    def title_sanitized(self, value):
-        self.title_sanitized = value
+    @property
+    def title_sanitize_tags(self) -> str:
+        if not self._title_sanitized:
+            self._title_sanitized = ManageTitles.clean_tags(self.title)
+        return self._title_sanitized
+
 
     @property
     def crew_list(self) -> list['str']:
@@ -219,21 +220,6 @@ class Media:
 
     @property
     def display_name(self):
-        if not self._display_name:
-            self._guess_filename = title.Guessit(self.title_sanitized)
-            guess = self._guess_filename.guessit
-            p2p_tags = P2pTags(filename=self.title_sanitized,
-                               title=guess.get("title", None),
-                               year=guess.get("year", ""),
-                               episode_title=guess.get("episode_title", None),
-                               mediafile_resolution=self.resolution,
-                               season=self.guess_season,
-                               episode=self.guess_episode,
-                               releaser_sign=config_settings.user_preferences.RELEASER_SIGN,
-                               tags_position=config_settings.user_preferences.TAGS_POSITION,
-                               mediafile=self.mediafile
-                               )
-            self._display_name = p2p_tags.process()
         return self._display_name
 
     @display_name.setter

{unit3dup-0.9.10 → unit3dup-0.9.12}/unit3dup/media_manager/ContentManager.py

@@ -135,10 +135,9 @@ class ContentManager:
         self.file_name = self.path
 
         # # Display name on webpage
-
-        # self.display_name, _ = os.path.splitext(os.path.basename(self.file_name))
-        # self.display_name = ManageTitles.clean_text(self.display_name)
-        # self.display_name = re.sub(r'[\[\]()]', '', self.display_name)
+        self.display_name, _ = os.path.splitext(os.path.basename(self.file_name))
+        self.display_name = ManageTitles.clean_text(self.display_name)
+        self.display_name = re.sub(r'[\[\]()]', '', self.display_name)
 
         # current media path
         self.torrent_path = self.path
@@ -164,8 +163,8 @@ class ContentManager:
         self.file_name = os.path.join(self.path, files_list[0])
 
         # # Display name on webpage
-        # self.display_name = ManageTitles.clean_text(os.path.basename(self.path))
-        # self.display_name = re.sub(r'[\[\]()]', '', self.display_name)
+        self.display_name = ManageTitles.clean_text(os.path.basename(self.path))
+        self.display_name = re.sub(r'[\[\]()]', '', self.display_name)
 
         # current media path
         self.torrent_path = self.path