plexer-cli 0.0.3.post4__py3-none-any.whl → 0.1.2__py3-none-any.whl

plexer_cli/const.py

@@ -4,4 +4,23 @@ Plexer - Normalize media files for use with Plex Media Server
 Module: Const - collection of global variables used across the application
 """
 
-METADATA_FILE_NAME = ".plexer"
+ARTIFACT_NAME_REGEX = r"^(.+) (\([\d]{4}\)) ?(\{edition-.+\})?$"
+ARTIFACT_HEURISTICS_PATTERNS = {
+    "name": r"^(.+?)([\.\-\_\(\[][1|2])",  # anything before the first instance of commonly-used separators
+    "common_editions": r"(?:[Dd]irector(?:')?s|[Ff]inal|[Ee]xtended|[Tt]heatrical|[Uu]nrated)[\.\-\_ ](?:Cut|Edit)|Uncut",  # common multi-word edition names (e.g., "Directors Cut", "Theatrical Edit", etc.)
+    "edition": r"([A-Za-z0-9']+)([\.\-\_ ]{1})([Ee][Dd][Ii][Tt][Ii][Oo][Nn])|(?:{edition-)(.+)(?:})",  # "XXX edition" (case-insensitive) or standard Plex format
+    "release_year": r"(19|20)([0-9]{2})",  # any 4 digit number between 1900 and 2099
+}
+ARTIFACT_FILE_TYPE_WHITELIST = [
+    # Videos
+    "video/mp4",
+    "video/x-matroska",  # .mkv
+    "video/x-msvideo"  # .avi
+    # Subtitles
+    "application/x-subrip"  # .srt
+    "text/plain"  # .sub subtitle files
+    "text/subtitle"  # .sub subtitle files (ALT)
+    "application/octet-stream"  # .sub index files
+    # Metadata
+    "text/x-nfo",  # .nfo
+]

plexer_cli/file_manager.py

@@ -5,12 +5,14 @@ Module: File Manager - code for file-related ops
 """
 
 import os
+import re
+
 from pathlib import Path
 from magic import from_file
 from logzero import logger
 
 from .artifact import Artifact
-from .const import METADATA_FILE_NAME
+from .const import ARTIFACT_NAME_REGEX, ARTIFACT_FILE_TYPE_WHITELIST
 from .metadata import Metadata
 
 
@@ -28,104 +30,222 @@ class FileManager:
 
     def get_artifacts(self, tgt_dir="") -> list:
         """
-        Gather the names of all files and directories in a given directory and return as list
-
+        Gather the names of all files and directories in a given directory and return as list.
 
-        Target directory is the source directory by default.
+        Target directory is the source directory by default, but can be specified via parameter.
         """
 
         artifacts = []
         tgt_dir = tgt_dir if tgt_dir else self.src_dir
 
         with os.scandir(tgt_dir) as sd_iter:
-            for artifact_entry in sd_iter:
+            for dir_artifact in sd_iter:
                 try:
-                    artifact_mime_type = from_file(artifact_entry.path, mime=True)
+                    artifact_mime_type = from_file(dir_artifact.path, mime=True)
                 except IsADirectoryError:
                     artifact_mime_type = "directory"
 
                 artifacts.append(
                     Artifact(
-                        name=artifact_entry.name,
-                        path=artifact_entry.path,
+                        name=dir_artifact.name,
+                        path=dir_artifact.path,
                         mime_type=artifact_mime_type,
                     )
                 )
 
         return artifacts
 
-    def prep_artifacts(self, artifacts: list) -> list:
+    def check_artifact(self, artifact: Artifact) -> bool:
         """
-        Perform any processing needed to prepare the artifact data for further processing
+        Perform any checks needed to determine if the artifact is valid for further processing
 
         Right now, this includes:
-            * Properly ordering artifacts such that the metadata file is first
+            * Checking if the artifact name is in a valid format required by Plex
         """
 
-        for idx, artifact in enumerate(artifacts):
-            if artifact.name == METADATA_FILE_NAME:
-                # float it to the top of the artifact set
-                artifacts.pop(idx)
-                artifacts.insert(0, artifact)
+        valid_artifact = False
 
-                break
+        artifact_name_reg = re.compile(ARTIFACT_NAME_REGEX)
+        if artifact_name_reg.match(artifact.name):
+            logger.debug(f"artifact name format is VALID: {artifact.name}")
 
-        return artifacts
+            valid_artifact = True
+        else:
+            logger.debug(f"artifact name format is INVALID: {artifact.name}")
+
+        return valid_artifact
+
+    def rename_artifact(
+        self, artifact: Artifact, video_metadata: Metadata, dry_run=False
+    ) -> Artifact:
+        """
+        Rename an artifact to the new name generated from the given metadata
 
-    def process_directory(self, dir_artifacts: list) -> None:
+        Returns the new, updated artifact object
         """
-        Traverse the given directory artifacts, rename the
-          video files accordingly, and delete everything else
 
-        NOTE: the artifact for the metadata file MUST come first
-          in the artifact list. Failing to do so may lead to instability
-          during artifact processing.
+        new_artifact_name = f"{video_metadata.name} ({video_metadata.release_year})"
+
+        if video_metadata.edition:
+            new_artifact_name += f" {{edition-{video_metadata.edition}}}"
+
+        # get artifact file info for srrc/dst path generation
+        artifact_file_path = Path(artifact.absolute_path)
+        artifact_parent_dir = artifact_file_path.parent
+        artifact_file_ext = (
+            "" if artifact.mime_type == "directory" else artifact_file_path.suffix
+        )
+
+        src_file = artifact_file_path.absolute()
+        dst_file = f"{artifact_parent_dir}/{new_artifact_name}{artifact_file_ext}"
+
+        logger.debug(
+            f"renaming artifact: [ OLD PATH: {src_file} ] to [ NEW PATH: {dst_file} ]"
+        )
+
+        if src_file != dst_file:
+            logger.debug(
+                f"executing rename operation on filesystem: {src_file} -> {dst_file}"
+            )
+            if not dry_run:
+                os.rename(src_file, dst_file)
+                artifact.name = new_artifact_name
+                artifact.absolute_path = dst_file
+            else:
+                logger.debug("dry run enabled; skipping actual rename operation")
+        else:
+            logger.debug(
+                "source and destination paths are identical; skipping rename operation"
+            )
+
+        return artifact
+
+    def analyze_artifact(
+        self, artifact: Artifact, prompt_behavior: str, dry_run: bool
+    ) -> Metadata:
+        """
+        Analyze the given artifact and return a Metadata object with the relevant info
         """
 
+        logger.debug(f"starting analysis of artifact: {artifact.name}")
+
+        # use heuristics to attempt to determine metadata from directory name
         video_metadata = Metadata()
+        video_metadata.metadata_found = False
 
-        logger.debug("starting directory artifact processing")
+        if video_metadata.do_heuristic_analysis(file_name=artifact.name):
+            logger.info(
+                f"metadata found for directory via heuristics - name: {video_metadata.name}, release_year: {video_metadata.release_year}",
+            )
+            video_metadata.metadata_found = True
 
-        for artifact in dir_artifacts:
+        if prompt_behavior == "all" or (
+            prompt_behavior == "default" and not video_metadata.metadata_found
+        ):
             logger.info(
-                "processing artifact: [ FILE: %s | PATH: %s | FILE TYPE: %s ]",
-                artifact.name,
-                artifact.absolute_path,
-                artifact.mime_type,
+                "user requested all prompts OR empty or incomplete metadata found for directory via heuristics; prompting user for manual input"
             )
+            video_metadata.prompt_user_for_metadata()
 
-            if artifact.mime_type == "directory":
-                logger.info("subdirectory found, processing")
+        return video_metadata
 
-                # start recursive subprocessing
-                new_dir_artifacts = self.get_artifacts(tgt_dir=artifact.absolute_path)
-                self.process_directory(dir_artifacts=new_dir_artifacts)
-            elif artifact.name == METADATA_FILE_NAME:
-                # read in video metadata
-                logger.info("metadata file found, importing")
+    def process_artifacts(
+        self,
+        artifacts: list,
+        video_metadata=Metadata(),
+        prompt_behavior="default",
+        dry_run=False,
+    ) -> None:
+        """
+        Traverse the given set of artifacts, rename the video files accordingly, and delete everything else.
 
-                video_metadata.import_metadata_from_file(
-                    file_path=artifact.absolute_path
+        Subdirectories are processed recursively.
+        """
+
+        logger.debug("starting artifact processing")
+
+        for artifact in artifacts:
+            logger.info(
+                f"processing artifact: [ FILE: {artifact.name} | PATH: {artifact.absolute_path} | FILE TYPE: {artifact.mime_type} ]"
+            )
+
+            if artifact.mime_type == "directory":
+                logger.info(
+                    "subdirectory found; assuming media directory and processing accordingly"
                 )
-            elif artifact.mime_type.startswith("video/"):
-                # move + rename
-                logger.info("video file found, renaming")
-
-                file_path = Path(artifact.absolute_path)
-                file_dir = file_path.parent
-                file_ext = file_path.suffix
-
-                src_file = artifact.absolute_path
-                dst_file = (
-                    f"{file_dir}/{video_metadata.name}"
-                    f" ({video_metadata.release_year}){file_ext}"
+
+                # perform analysis for video metadata
+                generated_video_metadata = self.analyze_artifact(
+                    artifact=artifact,
+                    prompt_behavior=prompt_behavior,
+                    dry_run=dry_run,
                 )
 
-                logger.debug("moving %s to %s", src_file, dst_file)
+                if generated_video_metadata.metadata_found:
+                    logger.info(
+                        "analysis successful, metadata found; renaming artifact based on gathered metadata"
+                    )
+
+                    artifact = self.rename_artifact(
+                        artifact=artifact,
+                        video_metadata=generated_video_metadata,
+                        dry_run=dry_run,
+                    )
 
-                os.rename(src_file, dst_file)
+                    video_metadata = generated_video_metadata
+                else:
+                    logger.warning(
+                        "no metadata found for directory after exhausting all methods; skipping artifact processing"
+                    )
+
+                    continue
+
+                # once metadata is available, start recursive subprocessing
+                new_dir_artifacts = self.get_artifacts(tgt_dir=artifact.absolute_path)
+                if new_dir_artifacts:
+                    self.process_artifacts(
+                        artifacts=new_dir_artifacts,
+                        video_metadata=video_metadata,
+                        prompt_behavior=prompt_behavior,
+                        dry_run=dry_run,
+                    )
             else:
-                # delete the file
-                logger.info("unnecessary file found, deleting")
+                if not video_metadata.metadata_found:
+                    raise ValueError(
+                        f"file artifact found ({artifact.name}) but no video metadata provided; unable to proceed"
+                    )
+
+                logger.info(
+                    f"file artifact found, processing accordingly: {artifact.name}"
+                )
+
+                # delete any files with file-types not whitelisted; rename whitelisted files accordingly
+                if artifact.mime_type not in ARTIFACT_FILE_TYPE_WHITELIST:
+                    logger.warning(
+                        f"file artifact is not a whitelisted file type; deleting: {artifact.name}"
+                    )
+                    if not dry_run:
+                        os.remove(artifact.absolute_path)
+                    else:
+                        logger.debug(
+                            "dry run enabled; skipping actual delete operation"
+                        )
+                else:
+                    logger.debug(
+                        "file artifact is a whitelisted file type", artifact.mime_type
+                    )
 
-                os.remove(artifact.absolute_path)
+                    if self.check_artifact(artifact=artifact):
+                        logger.info(
+                            "file artifact already in a valid format, skipping rename operation"
+                        )
+                    else:
+                        logger.info(
+                            "file artifact is NOT in a valid format; renaming accordingly"
+                        )
+
+                        artifact = self.rename_artifact(
+                            artifact=artifact,
+                            video_metadata=video_metadata,
+                            dry_run=dry_run,
+                        )

plexer_cli/main.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/usr/bin/env -S uv run
 """
 Plexer - Normalize media files for use with Plex Media Server
 
@@ -6,7 +6,7 @@ Main App Entrypoint
 """
 
 __author__ = "magneticstain"
-__version__ = "0.0.3-4"
+__version__ = "0.1.2"
 __license__ = "MIT"
 
 import argparse
@@ -17,6 +17,7 @@ from logzero import logger
 
 from plexer_cli.file_manager import FileManager
 
+
 def fetch_cli_args() -> argparse.Namespace:
     """Parse CLI arguments passed to the application during startup"""
 
@@ -31,6 +32,19 @@ def fetch_cli_args() -> argparse.Namespace:
     parser.add_argument("-s", "--source-dir", action="store", required=True)
     parser.add_argument("-d", "--destination-dir", action="store", required=True)
 
+    parser.add_argument(
+        "--prompt",
+        choices=["all", "none", "default"],
+        default="default",
+        help="Behavior to take in regards to user prompts (e.g. correcting names for overwriting files). all = prompt user for every artifact; none = never prompt - just trust the heuristics; default = prompt for incomplete matches only",
+    )
+
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Perform a trial run with no changes made",
+    )
+
     return parser.parse_args()
 
 
@@ -39,20 +53,29 @@ def main():
 
     cli_args = fetch_cli_args()
 
-    # logzero.json(enable=True)
-    logzero.loglevel(logzero.DEBUG)
-    logzero.logfile(None)
+    # logzero.logfile(None)
+    if cli_args.verbose == 1:
+        logzero.loglevel(logzero.INFO)
+    elif cli_args.verbose >= 2:
+        logzero.loglevel(logzero.DEBUG)
+    else:
+        logzero.loglevel(logzero.WARNING)
 
     logger.info("starting Plexer")
     logger.debug("options: %s", cli_args)
+    if cli_args.dry_run:
+        logger.info("performing a dry run; NO CHANGES WILL BE MADE")
 
     fm = FileManager(src_dir=cli_args.source_dir, dst_dir=cli_args.destination_dir)
 
-    # get and prep artifacts for processing
-    logger.debug("prepping artifacts for processing")
-    artifacts = fm.prep_artifacts(artifacts=fm.get_artifacts())
-    logger.info("%d artifact(s) found in source directory", len(artifacts))
-
     logger.info("processing artifacts")
-    fm.process_directory(dir_artifacts=artifacts)
+    fm.process_artifacts(
+        artifacts=fm.get_artifacts(),
+        prompt_behavior=cli_args.prompt,
+        dry_run=cli_args.dry_run,
+    )
     logger.info("artifact processing completed successfully")
+
+
+if __name__ == "__main__":
+    main()

plexer_cli/metadata.py

@@ -4,8 +4,11 @@ Plexer - Normalize media files for use with Plex Media Server
 Module: Metadata - code for analyzing and managing video metadata
 """
 
-import json
+import re
 from logzero import logger
+from prompt_toolkit import PromptSession
+
+from .const import ARTIFACT_HEURISTICS_PATTERNS
 
 
 class Metadata:
@@ -14,28 +17,120 @@ class Metadata:
     """
 
     name = ""
-    release_year = 0
+    edition = ""
+    release_year = 1900
+    metadata_found = False
 
-    def __init__(self, name="", release_year=1900) -> None:
+    def __init__(
+        self, name="", edition="", release_year=1900, metadata_found=False
+    ) -> None:
         self.name = name
-        self.release_year = release_year
+        self.edition = edition
+        if release_year >= 0:
+            self.release_year = release_year
+        self.metadata_found = metadata_found
+
+    def scrub_artifact_name(self, artifact_name: str) -> str:
+        """
+        Remove common separators and file extensions from given artifact name.
+
+        Typically used to produce a cleaner string as part of heuristic analysis.
+        """
+
+        logger.debug("scrubbing artifact name: %s", artifact_name)
+
+        # replace common separators with spaces and strip surrounding whitespace
+        scrubbed_name = re.sub(r"[\.\_\-\(\)\[\]]+", " ", artifact_name).strip()
+
+        logger.debug("artifact name post-scrubbing: %s", scrubbed_name)
+
+        return scrubbed_name
+
+    def prompt_user_for_metadata(self) -> None:
+        """
+        Prompt the user for metadata values via CLI input
+        """
+
+        logger.debug("prompting user for metadata input")
+
+        prompt_sess = PromptSession()
 
-    def import_metadata_from_file(self, file_path: str) -> None:
+        user_name = prompt_sess.prompt(
+            "Enter the correct name for this media: ", default=self.name
+        )
+        user_edition = prompt_sess.prompt(
+            "Enter the correct edition for this media (optional): ",
+            default=self.edition,
+        )
+        user_release_year = prompt_sess.prompt(
+            "Enter the release year for this media: ",
+            default=str(
+                self.release_year
+            ),  # `default` argument _must_ be a string, per docs
+        )
+
+        self.name = user_name
+        self.edition = user_edition
+        self.release_year = int(user_release_year)
+        self.metadata_found = True
+
+    def do_heuristic_analysis(self, file_name: str) -> bool:
         """
-        Read in given file and process data into metadata values
+        Analyze given file name and attempt to extract metadata values via heuristics
         """
 
-        logger.debug("metadata file found @ %s - importing data", file_path)
+        logger.debug("performing heuristic analysis on artifact: %s", file_name)
 
-        with open(file_path, mode="r", encoding="utf-8") as metadata_file:
-            imported_metadata = json.load(metadata_file)
+        # perform basic heuristics
+        ## NAME
+        possible_name = re.search(ARTIFACT_HEURISTICS_PATTERNS["name"], file_name)
+        if possible_name:
+            self.name = self.scrub_artifact_name(possible_name.group(1))
 
-        logger.debug("data imported as: %s", imported_metadata)
+        ## EDITION
+        # try checking for commonly-used edition names first
+        possible_edition = re.search(
+            ARTIFACT_HEURISTICS_PATTERNS["common_editions"], file_name
+        )
+        if possible_edition and possible_edition.group(0):
+            self.edition = self.scrub_artifact_name(possible_edition.group(0))
+        else:
+            # if common edition names aren't found, try using a more generic pattern
+            possible_edition = re.search(
+                ARTIFACT_HEURISTICS_PATTERNS["edition"], file_name
+            )
 
-        try:
-            self.name = imported_metadata["name"]
-            self.release_year = imported_metadata["release_year"]
-        except KeyError as e:
-            logger.error(
-                'data missing in metadata file; "%s" field was not found', e.args[0]
+            if possible_edition:
+                if possible_edition.group(1):
+                    self.edition = self.scrub_artifact_name(possible_edition.group(1))
+                elif possible_edition.group(2):
+                    self.edition = self.scrub_artifact_name(possible_edition.group(2))
+
+        ## RELEASE YEAR
+        possible_release_year = re.findall(
+            ARTIFACT_HEURISTICS_PATTERNS["release_year"], file_name
+        )
+        if possible_release_year:
+            # if multiple years are found, take the last one since it's more likely to be the correct value
+            # (e.g. "Movie.Name.1999.1080p.2020" should yield 2020 as the release year, not 1999)
+            self.release_year = int(
+                "".join(possible_release_year[-1])
+            )  # Ex: [('19', '99'), ('20', '20')] -> ('20', '20') -> 2020
+
+        if possible_name and possible_release_year:
+            logger.debug(
+                "heuristic analysis results - name: %s, edition: %s, release_year: %d",
+                self.name,
+                self.edition,
+                self.release_year,
             )
+
+            self.metadata_found = True
+            return True
+
+        logger.debug("heuristic analysis produced partial or no results")
+        self.metadata_found = (
+            False  # in case it has been overwritten from the default value
+        )
+
+        return False

{plexer_cli-0.0.3.post4.dist-info → plexer_cli-0.1.2.dist-info}/METADATA

@@ -1,11 +1,10 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.5
 Name: plexer_cli
-Version: 0.0.3.post4
-Summary: Normalize media files for use with Plex Media Server
-Project-URL: Repository, https://github.com/magneticstain/plexer.git
-Project-URL: Documentation, https://github.com/magneticstain/plexer#readme
+Version: 0.1.2
+Summary: Normalize media files and directories for use with Plex Media Server
+Project-URL: Repository, https://github.com/magneticstain/plexer
+Project-URL: Documentation, https://github.com/magneticstain/plexer-cli/wiki
 Project-URL: Issues, https://github.com/magneticstain/plexer/issues
-Project-URL: Source, https://github.com/magneticstain/plexer
 Author-email: Josh Carlson <837837+magneticstain@users.noreply.github.com>
 License-Expression: MIT
 License-File: LICENSE
@@ -16,16 +15,21 @@ Classifier: Framework :: Hatch
 Classifier: Framework :: Pytest
 Classifier: Framework :: tox
 Classifier: Intended Audience :: System Administrators
-Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: MacOS
 Classifier: Operating System :: Unix
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.9
+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
+Classifier: Topic :: Multimedia :: Video
 Classifier: Topic :: Utilities
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Requires-Dist: logzero~=1.7.0
+Requires-Dist: prompt-toolkit>=3.0.52
 Requires-Dist: python-magic~=0.4.27
 Description-Content-Type: text/markdown
 
@@ -41,8 +45,8 @@ Description-Content-Type: text/markdown
 ![GitHub Issues or Pull Requests](https://img.shields.io/github/issues/magneticstain/plexer)
 ![GitHub Downloads (all assets, all releases)](https://img.shields.io/github/downloads/magneticstain/plexer/total)
 
-[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/magneticstain/plexer/badge)](https://scorecard.dev/viewer/?uri=github.com/magneticstain/plexer)
-[![Codacy Badge](https://app.codacy.com/project/badge/Grade/38b2a65ed9ac4c85afc98e259d73474f)](https://app.codacy.com/gh/magneticstain/plexer/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
+[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/magneticstain/plexer-cli/badge)](https://scorecard.dev/viewer/?uri=github.com/magneticstain/plexer-cli)
+[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/13659/badge)](https://www.bestpractices.dev/projects/13659)
 
 [![Run Full Suite of Checks and Tests](https://github.com/magneticstain/plexer/actions/workflows/run_full_test_suite.yml/badge.svg)](https://github.com/magneticstain/plexer/actions/workflows/run_full_test_suite.yml)
 [![Release](https://github.com/magneticstain/plexer/actions/workflows/release.yml/badge.svg)](https://github.com/magneticstain/plexer/actions/workflows/release.yml)
@@ -60,15 +64,13 @@ Currently, Plexer only supports organizing movies and other individual video fil
 ### Roadmap
 
 - [ ] Support for TV Shows ([#28](https://github.com/magneticstain/plexer/issues/28))
-- [ ] Docker implementations ([#29](https://github.com/magneticstain/plexer/issues/29))
+- [X] Docker implementations ([#29](https://github.com/magneticstain/plexer/issues/29))
 - [ ] MacOS support ([#30](https://github.com/magneticstain/plexer/issues/30))
 - [ ] Windows support ([#31](https://github.com/magneticstain/plexer/issues/31))
-- [ ] Metadata inference using file/directory info (i.e. analyze the video files to "guess" what the name, year, etc is) ([#32](https://github.com/magneticstain/plexer/issues/32))
+- [X] Metadata inference using file/directory info (i.e. analyze the video files to "guess" what the name, year, etc is) ([#32](https://github.com/magneticstain/plexer/issues/32))
 
 ## Install
 
-To install Plexer, there are a few options available.
-
 ### Docker
 
 The most portable way to install and run Plexer is by using Docker.
@@ -89,7 +91,7 @@ docker run --rm -it magneticstain/plexer-cli
 docker run --rm -it ghcr.io/magneticstain/plexer-cli
 ```
 
-#### Via Local Build
+#### Via Local Image Build
 
 In the case that container registries are unavailable, there's also the option to build the image locally. To do that, check out the `main` branch of this repo, build the Plexer image, and run it.
 
@@ -101,21 +103,19 @@ docker run --rm -it plexer_cli
 
 ## Requirements
 
-### Media Metadata
+### Linux and MacOS Native Install
 
-The most important requirement before running plexer is to ensure that you've created a `.plexer` file in each of your target directories.
+If you've installed plexer-cli natively (i.e. outside of a Docker container) on Ubuntu, Devian, Fedora, etc, or MacOS, you will also need to install additional dependencies:
 
-This is a JSON-formatted file that includes the movie metadata required by Plexer to perform its jobs.
+#### Python-Magic
 
-#### Plexer File Generator
+While `python-magic` is imported in the standard fashion (via pip/python requirements), it itself depends on the presence of the libmagic C library. To install this library, follow [the installation instructions provided in the `python-magic` README](https://github.com/ahupp/python-magic?tab=readme-ov-file#installation).
 
-To easily create the `.plexer` file, you can use the one-liner below while in the movie's directory:
+### Media Metadata
 
-```bash
-echo -n "Media Name: ";read MEDIA_NAME;echo -n "Release Year (YYYY): ";read RELEASE_YEAR;echo "{\"name\": \"${MEDIA_NAME}\", \"release_year\": \"${RELEASE_YEAR}\"}" > .plexer
-```
+The most important requirement before running plexer is to ensure that you've created a `.plexer` file in each of your target directories.
 
-It can be modified to support different types of media as well.
+This is a JSON-formatted file that includes the movie metadata required by Plexer to perform its jobs.
 
 ## Usage
 
@@ -149,7 +149,17 @@ For developing with Plexer, there are several tools that are in use:
    1. [Hatch](https://hatch.pypa.io/1.12/)
 1. Analysis Tools:
    1. [Ruff](https://docs.astral.sh/ruff/)
-   1. [Codacy](https://app.codacy.com/gh/magneticstain/plexer/dashboard)
 1. Testing:
    1. [Pytest](https://docs.pytest.org/en/latest/)
    1. [Tox](https://tox.wiki/en/stable/)
+
+### Coding Standards and Conventions
+
+- Pre-commit hooks are utilized and managed in `.pre-commit-config.yml`
+  - For example, `ruff` is run as part of every commit
+  - These pre-commit hooks **MUST** be installed and utilized by all developers
+
+#### Testing
+
+- All functions **MUST** have unit tests created for them
+- Tests are executed using **VS Code** with the `launch.json` config file in `.vscode`

plexer_cli-0.1.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+plexer_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plexer_cli/artifact.py,sha256=JnaWeEM9msrs_EZpfGn7Xr1TcG8A7mUG-7BXuKNwXdU,378
+plexer_cli/const.py,sha256=fr7dfKuovYv5N7lo0sGgsDP59pmWDRdjktDWUTmLGB4,1169
+plexer_cli/file_manager.py,sha256=-1iV6UPnmwV1JJ5gTUrSz99O-Bm4zh2ljy6n2xX9wcI,9026
+plexer_cli/main.py,sha256=skc4OrYoSyG3ovqREjF7tIm7pQbJ3nrPjec29GpUtx0,2306
+plexer_cli/metadata.py,sha256=xot4tLGd_eAvaZcb17EY8w7LaNo7m2CUis5YSJEbHEw,4681
+plexer_cli-0.1.2.dist-info/METADATA,sha256=zOM_JQHmbf1OBwiy_Bh657l3uEEipPE-mZczOPCqw-k,7324
+plexer_cli-0.1.2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+plexer_cli-0.1.2.dist-info/entry_points.txt,sha256=0kHe-oXDezw_oNI1nB5LLLlFwMIhGN4QNv3h-mWWPHc,48
+plexer_cli-0.1.2.dist-info/licenses/LICENSE,sha256=cs3weOTez4n04m4foiWXOU6C6Pr83ORocewlbPDaJGs,1069
+plexer_cli-0.1.2.dist-info/RECORD,,

{plexer_cli-0.0.3.post4.dist-info → plexer_cli-0.1.2.dist-info}/WHEEL

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

plexer_cli-0.0.3.post4.dist-info/RECORD

@@ -1,11 +0,0 @@
-plexer_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-plexer_cli/artifact.py,sha256=JnaWeEM9msrs_EZpfGn7Xr1TcG8A7mUG-7BXuKNwXdU,378
-plexer_cli/const.py,sha256=U49nn11PvkOcvUf5eg1_hsYs12ULg_f2VtL81hWje-w,178
-plexer_cli/file_manager.py,sha256=nfmBnQXK8JWPp4INfLE6kVqeD6NMxFnn1YoTmywI4Dg,4153
-plexer_cli/main.py,sha256=HEvxX4g047KB4yM-719ZK1UR6mdciFvdMo5SLwIqeJ8,1687
-plexer_cli/metadata.py,sha256=UQ0nazq3agv7-h4NiVHNlpf2z_6rPLCBQ3TfIXKn0F8,1170
-plexer_cli-0.0.3.post4.dist-info/METADATA,sha256=Ou4zAgwRaPp4O9Kt_PCDWRCrvBR-_kX_wF-WaEQWk6M,6806
-plexer_cli-0.0.3.post4.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-plexer_cli-0.0.3.post4.dist-info/entry_points.txt,sha256=0kHe-oXDezw_oNI1nB5LLLlFwMIhGN4QNv3h-mWWPHc,48
-plexer_cli-0.0.3.post4.dist-info/licenses/LICENSE,sha256=cs3weOTez4n04m4foiWXOU6C6Pr83ORocewlbPDaJGs,1069
-plexer_cli-0.0.3.post4.dist-info/RECORD,,