romlm 1.0.1__py3-none-any.whl

romlm-1.0.1.dist-info/LICENSE

@@ -0,0 +1,22 @@
+
+The MIT License (MIT)
+
+Copyright (c) 2024-2025 Ilia Petrov-Komotskii (Mane Function)
+
+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.

romlm-1.0.1.dist-info/METADATA

@@ -0,0 +1,217 @@
+Metadata-Version: 2.1
+Name: romlm
+Version: 1.0.1
+Summary: A ROM library management tool.
+Author-email: Ilia Petrov-Komotskii <ilia@inkedkettle.art>
+License: MIT
+Project-URL: Homepage, https://github.com/ManeFunction/romlm
+Project-URL: Repository, https://github.com/ManeFunction/romlm
+Keywords: ROM,library,management,tools
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: py7zr==0.22.0
+Requires-Dist: tqdm==4.67.1
+Requires-Dist: colorama==0.4.6
+
+# romlm (ROMs Library Manager)
+
+A Python-based command line tool that helps you organize and manage your ROM collections effortlessly. 
+Whether you want to pack, unpack, sort, or remove duplicates, **romlm** has got you covered.
+
+All features are tested on the no-intro ROM sets (which I personally recommend), but it should work with any 
+ROM collection that follows a similar naming convention.
+If you have some issues with other ROM sets, that can't be worked-around with the current implementation, 
+feel free to open an issue on the [GitHub issues](https://github.com/ManeFunction/romlm/issues) page.
+
+---
+
+## Features
+
+- **Extract (`-x, --extract`)**  
+  Automatically unpacks all `.7z` or `.zip` files in the current directory (or a specified folder) into subfolders. 
+  Supports nested subfolders, keeping all the structure.
+
+  ![](https://raw.githubusercontent.com/wiki/ManeFunction/romlm/extract.png)
+
+
+- **Pack (`-p, --pack`)**  
+  Compresses all uncompressed files in the current directory (or a specified folder) into `.7z` or `.zip` archives. 
+  Supports nested subfolders, keeping all the structure.
+
+  ![](https://raw.githubusercontent.com/wiki/ManeFunction/romlm/pack.png)
+
+
+- **Sort (`-s, --sort`)**  
+  Moves files into alphabetically organized subfolders (A–Z). Optionally handles special folders for 
+  Homebrew (`!Homebrew`), Pirates (`!Pirates`), or user-defined subfolders (`-f`).
+    - `h` will also sort files into homebrew subfolder.
+    - `p` will also sort files into pirates subfolder.
+    - `f` will also sort files into user-defined subfolders (`-f`).
+    - `a` will also sort files into homebrew, pirates and all user-defined subfolders (`-f`). Equal to `hpf`.
+    - You can also use any combination of `h`, `p` and `f` options, for example `hp` or `fh`.
+    - `-s reverse` will reverse-sort files, i.e., move them all back into the root folder.
+  
+  ![](https://raw.githubusercontent.com/wiki/ManeFunction/romlm/sort.png)
+
+
+- **Separate Homebrew and Pirate ROMs (`-u, --unlicensed`)**  
+  By default, romlm detects and separates Homebrew or Pirate files into dedicated folders. Can be customized with 
+  options:
+    - `none` disables separation completely,
+    - `h` separates Homebrew files only,
+    - `p` separates Pirate files only.
+
+  ![](https://raw.githubusercontent.com/wiki/ManeFunction/romlm/unlicensed.png)
+
+
+- **Remove Duplicates (`-r, --remove-duplicates`)**  
+  Automatically detects duplicate files, preserving the best candidate according
+  to region, beta status, revision, version, release date and other data that can be received from the filename.
+  Behavior for the situations when script can't decide the best file itself, can be specified:
+    - `ask` prompts you which file to keep, default with `-l`,
+    - `all` keeps all equally good files, default without `-l`,
+    - `one` keeps exactly one of the best ROMs, taken randomly.
+
+  I highly recommend to **use this feature with `-l` option** to see the results, and **make a backup of your ROMs before**!
+  
+  In the current scenario it removes all the beta and prototype files if there is a final version of the game exists. 
+  If not, it tries to keep only one the latest version. USA retro ROMs (not Virtual Console versions) counts as 
+  the best version of the game. Also, Europe and EN releases have a higher priority over JP and Asia versions, 
+  as well as NTSC counts better, than PAL. **romlm** will never remove all copies of one game!
+  
+  If you want to keep a Japanese collection intact, I recommend to separate it first. See Usage Examples below.
+      
+  ![](https://raw.githubusercontent.com/wiki/ManeFunction/romlm/remove.png)
+
+
+- **User-defined Folders (`-f, --folders`)**  
+  Easily map certain tags to user-defined folders. For example, specifying `-f Japan` will move ROMs tagged 
+  as `(Japan)` into dedicated subfolder. Works only with `--sort` process as a part of it. Search only within tags, 
+  to not be confused with a game name, so if you just want all your Mario games in one place, just search it manually, 
+  **romlm** not for that.
+
+- **Exclude Tags (`-e, --exclude`)**  
+  Combine with `-f` to skip specified tags from the subfolders sorting process. For example, `-f Japan -e USA`
+  will move all `(Japan)` tagged ROMs into a dedicated subfolder, excluding any `(USA)` tagged ROMs
+  if `(Japan, USA)` combination is met.
+
+  ![](https://raw.githubusercontent.com/wiki/ManeFunction/romlm/subfolder.png)
+
+
+- **Logging (`-l, --log`)**  
+  Enables verbose output to see exactly what the script is doing. Extremely useful when `--remove-duplicates` is enabled.
+
+  ![](https://raw.githubusercontent.com/wiki/ManeFunction/romlm/remove-log.png)
+
+
+- **Other Utilities**  
+  - Cleans out unwanted system meta-files (e.g., `desktop.ini`, `.DS_Store`).
+  - Removes empty subdirectories after sorting.
+  - Provides an in-script help guide (`-h, --help`).
+
+---
+
+## Usage examples and backstory
+
+As a user of Analogue Pocket and an Emulation Station based handheld system, there are some nuances from both worlds 
+that I'm trying to cover with **romlm**. Analogue Poket is a highly precise FPGA-based console, but it covers only
+earlier generations and a scoop of Arcade games. Though, those platforms, like NES, SNES and Genesis have a huge
+library of games, that should be sorted to have an easy access. Also, Pocket do not support archives, so all the ROMs
+should be unpacked. Standard software emulators, on the other hand, can play archived ROMs, and with the support 
+of more later platforms, where games became bigger, it's great to have them packed, but also, it's good to have 
+old systems packed as well, to save some Gigs for a few more CD games. So, I've need a tool to prepare my ROMs 
+for both systems in a few clicks. That's how **romlm** was born.
+
+
+Personally, I keep all my ROMs on Analogue Pocket, to be able to quickly launch any version of any game it supports. 
+But I do not need all of those for a device that made for casual play. To be honest, I have Powkidy RGB30 with 
+a rectangular screen, specifically for the Pico-8. Emulation capabilities of this device is just a neat bonus 
+for me :) So, to prepare ROMs for Emulation Station devices, like Powkiddy, Anbernic, Miyoo, etc. we can clean 
+our library from all the stuff we never play anyway. 
+
+
+There is an example how to separate and work with your Japanese library, if you need it. But it also can be a great
+example of **romlm** capabilities for you to learn. Emulation Station have a separate folders for Japanese libraries 
+(at least for the 3 whales of retro gaming: NES, SNES and Genesis) as well as for homebrew, 
+so it's good to separate them first, if you are interested in them. Here is the way:
+1) `-i ./your-roms -s a -f Japan -e USA,EN` command first to separate non-en Japanese releases 
+(they ends up in `!Japan` folder). Alternatively, you can use `-s f` if your collection do not have a lot of homebrew
+and pirates, and you do not need to sort them in (A-Z) folders.
+1) Put all sorted folders (A-Z) from `your-roms` folder to `your-roms/sorted` for example, to be able to treat them
+separately later.
+1) Now you should have `sorted`, `!Japan`, `!Homebrew` (if there was any) and `!Pirates` (if there was any) 
+folders in your `your-roms` folder. `!` is used here to keep them on top of the list, as Emulation Station sorts
+folders alphabetically, but remember, that you should escape it with `\!` in the command line, so path 
+for the next commands should look like `-i ./your-roms/\!Japan` for example.
+1) Do `-i ./your-roms/sorted -r -l` for all the subfolders separately to remove duplicates, but keep them in 
+sorted (mostly USA for now) and Japanese folders.
+1) After that you can pack all the ROMs in one command `-i ./your-roms -p`. This command keeps our new folders structure.
+
+This way you will keep all the Japanese versions of the games, separated into a dedicated folder, and anyways
+all other duplicates will be removed, easing the access to the games you want to play in the future and
+saving the space on your device for more great games.
+
+
+---
+
+## Installation
+
+**romlm** is available to use in a variety of ways.  
+`pip` or `brew` is recommended ways, because they can handle dependencies and updates automatically.
+1) **brew (Recommended for Mac users)**
+    - You can install **romlm** through the [Homebrew](https://brew.sh/) formula for macOS users (if you have **brew** installed), 
+      typing `brew install romlm` in the Terminal.
+    - Verify the installation with `romlm -h` command.
+    - You are perfect, you can use the app with `romlm [parameters]` command from any folder in your system.
+1) **Ready to use binaries (Mac and Windows)**
+    - Download ready-to-use binaries from the [GitHub Releases](https://github.com/ManeFunction/romlm/releases) and run it with `./romlm`.  
+    - Unpack the downloaded archive.
+    - On Mac:
+      - Open Terminal or any other CL app you prefer to use.
+      - Run `cd path/to/unpacked/folder` to go to the folder (you can just drag'n'drop a folder to the Terminal
+        to copy-paste its path).
+      - Run `xattr -r -d com.apple.quarantine ./` to remove the quarantine attribute from binaries  
+        (I do not have an Apple Developer status at the moment and cannot sign binaries properly, 
+        this, hopefully, will be fixed in the future).
+      - Run `./romlm -h` to verify the script is working  
+        (be aware, that macOS still running security checks, so the first start of the app will be longer for about 10-15 sec.).
+      - You are perfect, you can use the app now with `./romlm [parameters]` command.
+    - On Windows (cmd):
+      - Open Command Prompt (cmd) with `Win+R` and typing `cmd`, or just searching `cmd` in a Start menu.
+      - Run `cd path\to\folder` to go to the folder with `romlm.exe`.  
+        Don't forget to use `cd` with `/d` option to change the drive, if needed (`cd /d path\to\folder`).
+      - Run `romlm -h` to verify the script is working.
+      - You are perfect, you can use the app now with `romlm [parameters]` command.
+    - On Windows (PowerShell):
+      - Open PowerShell searching it in a Start menu.
+      - Run `cd path\to\folder` to go to the folder with `romlm.exe`.
+      - Run `./romlm -h` to verify the script is working.
+      - You are perfect, you can use the app now with `./romlm [parameters]` command.
+1) **Python package (manual installation)**
+      - Clone the repository or download the source code from the GitHub.
+      - Go to the folder with the script in your Terminal.
+      - Run `pip install .` to install `romlm` to your system.
+      - Run `romlm -h` to verify the script is working.
+      - You are perfect, you can use `romlm [parameters]` command from anywhere in your system.
+1) **Python script (manual usage, for advanced users)**
+    - if you know how to work with Python scripts, venv, and dependencies, you can simply clone the repository 
+      and run `romlm.py`. In that way, feel free to modify the script for yourself as you want.
+
+---
+
+## Credits
+
+Created and maintained by ManeFunction.
+
+Huge thanks to the [no-intro](http://www.no-intro.org/) team for their amazing work on the ROM sets and retro games
+preservation.
+
+Also, big shoutout to the [Nuitka](https://github.com/Nuitka/Nuitka) project for the great Python compiler.
+
+And of course, thanks for your contributions and feedback!
+If you have any questions, suggestions, or issues, feel free to open an issue on the [GitHub issues](https://github.com/ManeFunction/romlm/issues) page 
+or create a or pull request.

romlm-1.0.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+romlm.py,sha256=H2kO5L2VinZebPz1Elk3RrhTvHmdbD2W98EXAoDBSgw,29040
+romlm-1.0.1.dist-info/LICENSE,sha256=dUZoH9bnH42wYZjubCnqbxhGhe6nLIIrCe_QuMXkxP4,1110
+romlm-1.0.1.dist-info/METADATA,sha256=JPWxQA0ChyFHk7l6HM01wl44dSe771j8IDDduPtdDVQ,12213
+romlm-1.0.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+romlm-1.0.1.dist-info/entry_points.txt,sha256=MdkUwQXpkvv903lE4hyw3HBPS9T8pZYHIBXT1ZM4mvw,37
+romlm-1.0.1.dist-info/top_level.txt,sha256=a4a-r2xK1ooyTkj-PVk6U7497i5rkmmWKVl8XfxPzDs,6
+romlm-1.0.1.dist-info/RECORD,,

romlm-1.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.6.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

romlm-1.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+romlm = romlm:mane

romlm-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+romlm

romlm.py

@@ -0,0 +1,820 @@
+import sys
+import os
+import re
+import shutil
+import glob
+from enum import Enum, Flag, auto
+import py7zr
+import zipfile
+import colorama
+from colorama import Fore, Style
+from tqdm import tqdm
+from multiprocessing import Pool, freeze_support
+
+version = "1.0.1"
+
+def print_help():
+	print("Usage: \033[1mromlm\033[0m [parameters]")
+	print("Parameters:\n")
+	print("-i, --input [folder]         Specify the input folder.")
+	print("                             Default is the current folder.\n")
+	print("-s, --sort [options]         Sort files into lettered subfolders (A-Z).")
+	print("                             Options indicates is special folders should be")
+	print("                             also sorted. Can be:")
+	print("                             'h' - homebrew")
+	print("                             'p' - pirates")
+	print("                             'f' - user-defined folders")
+	print("                             'a' - all")
+	print("                             or use any combinations, like 'hp' or 'ps'.")
+	print("                             'reverse' - un-sort ROMs, placing all in the root.\n")
+	print("-x, --extract                Extract all 7z/zip files in the folder.\n")
+	print("-p, --pack [format]          Pack all files in the folder to 7z/zip format.")
+	print("                             [format] can be '7z' or 'zip'. Default is '7z'.\n")
+	print("-u, --unlicensed [options]   Disable Homebrew and Pirate stuff separation")
+	print("                             to the different folders. [options] can be:")
+	print("                             'h' - separate homebrew only")
+	print("                             'p' - separate pirates only")
+	print("                             'none' - do not separate anything")
+	print("                             Separation enabled by default.\n")
+	print("-r, --remove-duplicates      Remove duplicate files.")
+	print("                             When program stuck with more than one 'best' ROMs:")
+	print("                             'ask' - will ask which file to keep.")
+	print("                             'all' - will keep all best files.")
+	print("                             'one' - will keep only one best file (at random).")
+	print("                             If --log, default is 'ask', otherwise 'all'.")
+	print("                             --log is recommended for this process.\n")
+	print("-f, --folders [list]         Define subfolders to place files, based on tags.\n")
+	print("-e, --exclude [list]         Exclude files with specified tags from -f process.\n")
+	print("-h, --help                   Show this help message.\n")
+	print("-l, --log                    Enable full logging instead of progressbars.\n")
+	print("For more details and examples or to support an author,")
+	print("please check the README file or visit the GitHub repository:")
+	print(f"{Fore.CYAN}https://github.com/ManeFunction/romlm{Style.RESET_ALL}")
+
+class Action(Enum):
+	NOT_DEFINED = 0
+	ASK = 1
+	KEEP_ALL = 2
+	KEEP_ONE = 3
+	
+class CategoryOption(Flag):
+	HOMEBREW = auto()
+	PIRATES = auto()
+	SUBFOLDERS = auto()
+
+def create_if_not_exist(folder):
+	if not os.path.exists(folder):
+		os.makedirs(folder)
+		
+def get_lettered_folder_name(filename) -> str:
+	folder_name = filename[0].upper() if filename else ''
+	if folder_name == "[":
+		folder_name = "!!BIOS"
+	elif not folder_name.isalpha():
+		folder_name = "1-9"
+	return folder_name
+
+def try_add_subfolder(is_sort_subfolders, folder_name, filename) -> str:
+	return (folder_name + "/" + get_lettered_folder_name(filename)) if is_sort_subfolders else folder_name
+
+def get_tags_from_filename(filename: str) -> list[str]:
+	name_no_ext = os.path.splitext(filename)[0]
+	groups = re.findall(r'[(\[](.*?)[)\]]', name_no_ext)
+	all_tags = []
+	for g in groups:
+		split_tags = [t.strip() for t in g.split(',')]
+		all_tags.extend(split_tags)
+	return [tag.lower() for tag in all_tags]
+
+def is_homebrew(file_tags) -> bool:
+	return "homebrew" in file_tags or "aftermarket" in file_tags
+
+def is_pirate(file_tags) -> bool:
+	return "pirate" in file_tags or "unl" in file_tags
+
+def get_new_folder(filename, separation_options, sorting_options, subfolders, excludes) -> str:
+	file_tags = get_tags_from_filename(filename)
+	excludes = {exclude.lower() for exclude in excludes} if excludes is not None else None
+	
+	# Check for 'homebrew' or 'aftermarket' tags
+	if separation_options & CategoryOption.HOMEBREW and is_homebrew(file_tags):
+		folder_name = try_add_subfolder(sorting_options & CategoryOption.HOMEBREW, "!Homebrew", filename)
+		
+	# Check for 'pirate' or 'unl' tags
+	elif separation_options & CategoryOption.PIRATES and is_pirate(file_tags):
+		folder_name = try_add_subfolder(sorting_options & CategoryOption.PIRATES, "!Pirates", filename)
+
+	# Check for any user-defined 'subfolders' value matches any tag.
+	elif subfolders is not None:
+		found_subfolder = ""
+		for subfolder in subfolders:
+			if subfolder.lower() in file_tags and (excludes is None or not bool(excludes.intersection(file_tags))):
+				found_subfolder = "!" + subfolder
+				break
+		folder_name = try_add_subfolder(sorting_options & CategoryOption.SUBFOLDERS, found_subfolder, filename) \
+			if found_subfolder != "" else get_lettered_folder_name(filename)
+
+	# Default to alphabetical folder
+	else:
+		folder_name = get_lettered_folder_name(filename)
+
+	create_if_not_exist(folder_name)
+	return folder_name
+
+def remove_meta_files(path, is_log_enabled):
+	for dirpath, dirnames, filenames in os.walk(path):
+		for f in filenames:
+			if f.lower() in ("desktop.ini", "thumbs.db", ".ds_store"):
+				file_path = os.path.join(dirpath, f)
+				os.remove(file_path)
+				if is_log_enabled:
+					print(f"Removed meta file: {Fore.RED}{file_path}{Style.RESET_ALL}")
+
+def remove_empty_subfolders(path, is_log_enabled):
+	for dirpath, dirnames, filenames in os.walk(path, topdown=False):
+		if not dirnames and not filenames:
+			if dirpath != path:
+				os.rmdir(dirpath)
+				if is_log_enabled:
+					print(f"Removed empty folder: {Fore.RED}{dirpath}{Style.RESET_ALL}")
+				# Kinda cludgy, but keep removing empty parent folders until we hit the root, to clear empty trees
+				parent_dir = os.path.dirname(dirpath)
+				while parent_dir != path and not os.listdir(parent_dir):
+					os.rmdir(parent_dir)
+					if is_log_enabled:
+						print(f"Removed empty folder: {Fore.RED}{parent_dir}{Style.RESET_ALL}")
+					parent_dir = os.path.dirname(parent_dir)
+
+def get_base_name(filename: str) -> str:
+	name_no_ext = os.path.splitext(filename)[0]
+	idx_1 = name_no_ext.find('(')
+	idx_2 = name_no_ext.find('[')
+	idx = min(idx_1, idx_2) if idx_1 != -1 and idx_2 != -1 else max(idx_1, idx_2)
+	if idx != -1:
+		base = name_no_ext[:idx].strip()
+	else:
+		base = name_no_ext.strip()
+	return base
+		
+def clean_duplicates(file_list, action, is_log_enabled, is_debug_log):
+	"""
+    For each distinct base name (game):
+      1) Partition into normal vs beta/proto.
+         - If normal exists => remove all beta/proto.
+      2) Among normal => pick exactly one best-scored normal file:
+         - Region coverage (more is better)
+         - Fewer non-region tags
+         - Better (lower) region priority index
+         - Higher revision
+      3) If no normal => pick exactly one best-scored beta/proto:
+         - Region coverage (more is better)
+         - No date is better than having a date
+         - Higher numeric suffix is better
+         - Fewer non-region tags
+      4) Remove the rest. Never remove all for a given game; if end up with none, keep them all.
+    """
+
+	top_region_priority = "world"
+	region_priority = ["usa", "europe"]
+	asian_regions = ["japan", "asia", "china", "korea"]
+
+	# Is ROM a part of multi-disc set?
+	def get_disc_number(tags_list) -> int:
+		"""
+		Returns '-1' if the ROM is not a part of a multi-disc set, or disc number otherwise.
+		"""
+		for t in tags_list:
+			m = re.match(r"(disc|disk)\s*(\d+)", t)
+			if m:
+				return int(m.group(2))
+		return -1
+
+	# Helper: parse date like (1993-07-09)
+	def parse_date_yyyy_mm_dd(tag: str) -> bool:
+		"""
+        Return True if tag looks like YYYY-MM-DD, else False.
+        We won't parse the integer, we just treat "has date" as a boolean.
+        """
+		return bool(re.match(r"^\d{4}-\d{2}-\d{2}$", tag))
+
+	# Identify if file is Beta/Proto/Sample
+	def is_beta_file(fpath):
+		tags_list = get_tags_from_filename(os.path.basename(fpath))
+		for t in tags_list:
+			# If it starts with "beta", "proto", or "sample", we treat it as Beta/Proto
+			if (t.startswith("beta") 
+					or t.startswith("alpha")
+					or t.startswith("proto") 
+					or t.startswith("sample")
+					or t.startswith("demo")):
+				return True
+		return False
+
+	# Region coverage + min region index
+	def get_region_coverage_and_min_index(tags_list):
+		"""
+        Returns (coverage, min_index) where:
+          coverage = number of recognized region tags
+          min_index = the lowest index among recognized tags (or len(region_priority) if none)
+        Example: if tags_list has ["usa", "europe"], coverage=2, min_index=1 ("usa")
+        """
+		# Check if it's a top region priority
+		for t in tags_list:
+			if t == top_region_priority:
+				return len(region_priority), 0
+		# Check if it's a recognized prioritized region
+		recognized = [r for r in tags_list if r in region_priority]
+		coverage = len(recognized)
+		if coverage == 0:
+			return 0, len(region_priority)
+		# find the lowest region index among them
+		min_i = min(region_priority.index(r) for r in recognized)
+		return coverage, min_i
+	
+	# Is ROM from an Asian region?
+	def is_asian_region_and_not_en(tags_list):
+		"""
+		Returns True if the ROM is from an Asian region and not in English.
+		"""
+		is_asian = False
+		is_en = False
+		for t in tags_list:
+			if t in asian_regions:
+				is_asian = True
+			elif t == "en":
+				is_en = True
+		return is_asian and not is_en
+
+	# Count how many unknown tags ROM have (excluding rev, beta/proto, sample, known region)
+	def count_unknown_tags(tags_list):
+		count = 0
+		for t in tags_list:
+			# Skip known regions tags
+			if t == top_region_priority:
+				continue
+			if t in region_priority:
+				continue
+			if t in asian_regions:
+				continue
+			# Revisions and versions tags
+			if t.startswith("rev ") or re.match(r"^\d+(?:\.\d+){0,3}$", t):
+				continue
+			# Beta and other in-development tags
+			if t.startswith("beta") or t.startswith("alpha") or t.startswith("proto") or t.startswith("sample"):
+				continue
+			# Language tags
+			if t in ["en", "fr", "de", "es", "it", "nl", "pt", "sv", "no", "da", "fi"]:
+				continue
+			# anything else is "extra"
+			count += 1
+		return count
+
+	# Get video format score for comparison (NTSC > none > PAL)
+	def get_video_format_score(tags_list) -> int:
+		"""
+		Convert a video format tag into a single integer for comparison.
+		"""
+		if "ntsc" in tags_list:
+			return 2
+		if "pal" in tags_list:
+			return 0
+		return 1
+	
+	# Try to get version from tags list
+	def try_get_version_score(tags_list) -> tuple[int, bool]:
+		for t in tags_list:
+			# Catch numeric revisions
+			m = re.match(r"^(rev|proto|alpha|beta|sample|demo)\s+([a-z])$", t)
+			if m:
+				rev = m.group(2)[0]
+				rev_score = ord(rev) - ord('a') + 1
+				return rev_score, True
+			# Catch version numbers
+			m = re.match(r"^(?:(rev|beta|alpha|proto|sample|demo)\s+)?v?(\d+(?:\.\d+){0,3})?$", t)
+			if m:
+				version_str = m.group(2)
+				parts = version_str.split(".")
+				version_tuple = tuple(map(int, parts)) + (0,) * (4 - len(parts))
+				version_score = int("".join(f"{v:03}" for v in version_tuple))
+				return version_score, True
+		return 0, False
+	
+	# Get the date score from tags list
+	def get_date_score(tags_list) -> int:
+		for t in tags_list:
+			if parse_date_yyyy_mm_dd(t):
+				date_score = int(t.replace("-", ""))
+				return date_score
+		return 0
+
+	# Normal-file scoring: ( -region_coverage, min_region_index, non_region_tags, -video_format, -revision, -date )
+	def score_normal_file(fpath):
+		tags_list = get_tags_from_filename(os.path.basename(fpath))
+		
+		coverage, min_idx = get_region_coverage_and_min_index(tags_list)
+		video_format_score = get_video_format_score(tags_list)
+		non_region = count_unknown_tags(tags_list)
+		date_score = get_date_score(tags_list)
+		
+		version_score, version_found = try_get_version_score(tags_list)
+		
+		# Set a slight tags penalty for Asian regions to prioritize english versions even it's new (from Virtual Consoles, etc.)
+		if is_asian_region_and_not_en(tags_list):
+			non_region += 2
+			
+		# For Homebrew, assume that no explicit revision version is 1.0.0.0 (initial release)
+		# ...for retro ROMs, it's more likely "Rev 0" (initial release)
+		# also compensate missed initial revision for Homebrew 
+		if (is_homebrew(tags_list) or is_pirate(tags_list)) and not version_found:
+			version_score = 100000000000
+			non_region += 1
+			
+		if is_debug_log:
+			print(f"  >>> {fpath} (RELEASE): {Fore.MAGENTA}tags({non_region}), reg({coverage}: {min_idx}), "
+				  f"format({video_format_score}), v({version_score}:{date_score}){Style.RESET_ALL}")
+		
+		return (
+			non_region,
+			-coverage,
+			min_idx,
+			-video_format_score,
+			-version_score,
+			-date_score
+		)
+
+	# Beta/Proto scoring: ( -latest_date, -region_coverage, -beta_number, non_region_tags )
+	def score_beta_file(fpath):
+		tags_list = get_tags_from_filename(os.path.basename(fpath))
+		
+		coverage, _ = get_region_coverage_and_min_index(tags_list)
+		best_date_score = get_date_score(tags_list)
+		non_region = count_unknown_tags(tags_list)
+
+		version_score, _ = try_get_version_score(tags_list)
+		
+		if is_debug_log:
+			print(f"  >>> {fpath} (BETA): {Fore.MAGENTA}date({best_date_score}), reg({coverage}), v({version_score}), "
+				  f"tags({non_region}){Style.RESET_ALL}")
+		
+		return (
+			-best_date_score,
+			-coverage,
+			-version_score,
+			non_region
+		)
+
+	# Print list of files in a color
+	def print_files_list(files_list, color):
+		for file_name in files_list:
+			print(f" - {color}{os.path.basename(file_name)}{Style.RESET_ALL}")
+			
+	# Get a log iteration string formatted as "(N/M)"
+	def n(index) -> str:
+		return f"({index}/{len(groups_iter)}) "
+	
+	# Left only one file in the set
+	def keep_one(files_set, selected) -> set:
+		if is_log_enabled:
+			print(f"{n(i)}Removing duplicate(s):")
+		for file_name in files_set:
+			if file_name != selected:
+				if is_log_enabled:
+					print(f"- {Fore.RED}{os.path.basename(file_name)}{Style.RESET_ALL}")
+				os.remove(file_name)
+		if is_log_enabled:
+			print(f"| >> Keeping one: {Fore.GREEN}{os.path.basename(selected)}{Style.RESET_ALL}")
+		return {selected}
+
+	# Group files by base name
+	file_list = list(file_list)
+	by_basename = {}
+
+	for f in file_list:
+		fname = os.path.basename(f)
+		base = get_base_name(fname)
+		disc = get_disc_number(get_tags_from_filename(fname))
+		if disc > -1:
+			base += f" (Disc {disc})"
+		by_basename.setdefault(base, []).append(f)
+
+	print(
+		">> Removing duplicates safely... \nTotal ROMs:",
+		len(file_list),
+		"\nActual games:",
+		len(by_basename),
+	)
+
+	files_to_keep = set()
+
+	# MAIN LOOP of removing duplicates
+	groups_iter = by_basename.items() if is_log_enabled \
+		else tqdm(by_basename.items(), desc="Cleaning Duplicates", total=len(by_basename))
+
+	i = 0
+	for base, paths in groups_iter:
+		i += 1
+		
+		# Only one file => trivially keep it
+		if len(paths) == 1:
+			files_to_keep.add(paths[0])
+			if is_log_enabled:
+				print(f"{n(i)}Single ROM: {Fore.GREEN}{os.path.basename(paths[0])}{Style.RESET_ALL}")
+			continue
+
+		# Partition into normal vs. beta/proto
+		normal_files = []
+		beta_proto_files = []
+		for p in paths:
+			if is_beta_file(p):
+				beta_proto_files.append(p)
+			else:
+				normal_files.append(p)
+
+		if normal_files:
+			# Remove all Beta/Proto
+			chosen_set = normal_files
+			if is_log_enabled and beta_proto_files:
+				print(f"{n(i)}Removing all Betas: ")
+				print_files_list(beta_proto_files, Fore.RED)
+				print(f" | >> Has {len(normal_files)} release(s):")
+				print_files_list(normal_files, Fore.GREEN)
+			for bp in beta_proto_files:
+				os.remove(bp)
+		else:
+			# No normal => only Beta/Proto
+			# Pick exactly one best-scored
+			if len(beta_proto_files) == 1:
+				files_to_keep.add(beta_proto_files[0])
+				if is_log_enabled:
+					print(f"{n(i)}Single Beta: {Fore.GREEN}{os.path.basename(beta_proto_files[0])}{Style.RESET_ALL}")
+				continue
+
+			best_bp = None
+			best_score = None
+			for bp in beta_proto_files:
+				sc = score_beta_file(bp)
+				if (best_score is None) or (sc < best_score):
+					best_score = sc
+					best_bp = bp
+
+			keep_set = {best_bp}
+			for bp in beta_proto_files:
+				if bp != best_bp:
+					if is_log_enabled:
+						print(f"{n(i)}Removing earlier Beta: {Fore.RED}{os.path.basename(bp)}{Style.RESET_ALL}")
+					os.remove(bp)
+
+			# safety check: never remove all
+			if not keep_set:
+				# fallback => keep them all
+				for p in beta_proto_files:
+					files_to_keep.add(p)
+				if is_log_enabled:
+					print(f"{n(i)}No latest Beta, keeping all:")
+					print_files_list(beta_proto_files, Fore.GREEN)
+			else:
+				for f in keep_set:
+					files_to_keep.add(f)
+				if is_log_enabled:
+					print(f"{n(i)}Latest Beta: {Fore.GREEN}{os.path.basename(best_bp)}{Style.RESET_ALL}")
+			continue
+
+		# If chosen_set is empty for some reason, fallback => keep them all
+		if not chosen_set:
+			for p in paths:
+				files_to_keep.add(p)
+			if is_log_enabled:
+				print(f"{n(i)}No release ROMs, keeping all these:")
+				print_files_list(paths, Fore.GREEN)
+			continue
+
+		# Among the chosen normal set, pick best scored files
+		if len(chosen_set) == 1:
+			files_to_keep.add(chosen_set[0])
+			if is_log_enabled:
+				print(f"{n(i)}Single release ROM: {Fore.GREEN}{os.path.basename(chosen_set[0])}{Style.RESET_ALL}")
+			continue
+
+		best_normal = set()
+		best_score = None
+		for nf in chosen_set:
+			sc = score_normal_file(nf)
+			if (best_score is None) or (sc < best_score):
+				best_score = sc
+				best_normal = {nf}
+			elif sc == best_score:
+				best_normal.add(nf)
+
+		# remove all others
+		keep_set = best_normal
+		for nf in chosen_set:
+			if nf not in best_normal:
+				if is_log_enabled:
+					print(f"{n(i)}Removing duplicate: {Fore.RED}{os.path.basename(nf)}{Style.RESET_ALL}")
+				os.remove(nf)
+
+		# safety check
+		if not keep_set:
+			# fallback => keep them all
+			for f in chosen_set:
+				files_to_keep.add(f)
+			if is_log_enabled:
+				print(f"{n(i)}No best ROM, keeping all:")
+				print_files_list(chosen_set, Fore.GREEN)
+		else:
+			# check what we need to do with the rest of the best
+			if len(keep_set) > 1:
+				if action == Action.KEEP_ALL:
+					if is_log_enabled:
+						print(f"{n(i)}Keeping all best ROMs:")
+						print_files_list(keep_set, Fore.GREEN)
+						
+				elif action == Action.KEEP_ONE:
+					best_kept = min(keep_set, key=lambda x: x)
+					keep_set = keep_one(keep_set, best_kept)
+					
+				elif action == Action.ASK:
+					print(f"{n(i)}Can't decide which one is the best. Please select one to keep:")
+					keep_list = list(keep_set)
+					for idx, file in enumerate(keep_list, start=1):
+						print(f" {idx}. {Fore.YELLOW}{os.path.basename(file)}{Style.RESET_ALL}")
+					
+					selected_index = -1
+					while selected_index < 0 or selected_index > len(keep_list):
+						try:
+							selected_index = int(input("Enter the number of the file to keep (0 to keep all): "))
+						except ValueError:
+							print("Invalid input. Please enter a number.")
+					
+					if selected_index == 0:
+						if is_log_enabled:
+							print(f"{n(i)}Keeping all best ROMs:")
+							print_files_list(keep_set, Fore.GREEN)
+					else:
+						user_selected = keep_list[selected_index - 1]
+						keep_set = keep_one(keep_set, user_selected)
+			
+			if len(keep_set) == 1:
+				if is_log_enabled:
+					print(f"{n(i)}Best ROM: {Fore.GREEN}{os.path.basename(next(iter(keep_set)))}{Style.RESET_ALL}")
+			
+			for f in keep_set:
+				files_to_keep.add(f)
+
+	# Return only files we decided to keep
+	return [f for f in file_list if f in files_to_keep]
+
+def process_file(args) -> tuple[str, str]:
+	"""Processes a single file for packing or unpacking."""
+	file_name, target_folder, is_unpacking_enabled, is_packing_enabled, packing_format = args
+	result_log = None
+	if is_unpacking_enabled and file_name.endswith((".7z", ".zip")):
+		result_log = unpack_file(file_name, target_folder)
+	elif is_packing_enabled and not file_name.endswith((".7z", ".zip")) and not file_name.startswith("[BIOS]"):
+		result_log = pack_file(file_name, target_folder, packing_format)
+	return file_name, result_log
+
+def unpack_file(file_name, target_folder) -> str:
+	"""Handles unpacking of a single file."""
+	if file_name.endswith(".7z"):
+		with py7zr.SevenZipFile(file_name, 'r') as archive:
+			archive.extractall(target_folder)
+	elif file_name.endswith(".zip"):
+		with zipfile.ZipFile(file_name, 'r') as archive:
+			archive.extractall(target_folder)
+	os.remove(file_name)
+	return f" >> Unpacked to: {Fore.BLUE}{target_folder}{Style.RESET_ALL}"
+
+def pack_file(file_name, target_folder, packing_format) -> str:
+	"""Handles packing of a single file."""
+	archive_path = os.path.join(target_folder, os.path.basename(file_name))
+	if packing_format == "7z":
+		with py7zr.SevenZipFile(str(archive_path) + ".7z", 'w') as archive:
+			archive.write(file_name, arcname=os.path.basename(file_name))
+	elif packing_format == "zip":
+		with zipfile.ZipFile(str(archive_path + ".zip"), 'w', zipfile.ZIP_DEFLATED) as archive:
+			archive.write(file_name, arcname=os.path.basename(file_name))
+	os.remove(file_name)
+	return f" >> Packed to: {Fore.BLUE}{archive_path}.{packing_format}{Style.RESET_ALL}"
+
+def is_next_optional_parameter(args, i) -> bool:
+	return i+1 < len(args) and not args[i+1].startswith("-")
+
+def mane():
+	# check for -v or --version argument
+	if len(sys.argv) == 2 and sys.argv[1] in ("-v", "--version"):
+		print(f"ROMs Library Manager v{version}")
+		sys.exit()
+	
+	# Print welcome message and init variables
+	print(f">> Welcome to ROMs Library Manager (v{version})")
+
+	separation_options = CategoryOption.HOMEBREW | CategoryOption.PIRATES
+	is_sort_enabled = False
+	sort_options = CategoryOption(0)
+	is_reverse_sort = False
+	is_unpacking_enabled = False
+	is_packing_enabled = False
+	packing_format = "7z"
+	is_log_enabled = False
+	is_debug_log = False
+	is_remove_duplicates = False
+	remove_duplicates_action = Action.NOT_DEFINED
+	subfolders = None
+	exclude_tags = None
+	input_folder = "."
+
+	colorama.init()
+
+	# Parse command line arguments
+	args = sys.argv[1:]
+	skip_next = False
+	for i, arg in enumerate(args):
+		if skip_next:
+			skip_next = False
+			continue
+		if arg in ("-h", "--help"):
+			print_help()
+			sys.exit()
+		if arg in ("-x", "--extract"):
+			is_unpacking_enabled = True
+		elif arg in ("-p", "--pack"):
+			is_packing_enabled = True
+			if is_next_optional_parameter(args, i):
+				pack_param = args[i+1]
+				if pack_param == "7z":
+					packing_format = "7z"
+				elif pack_param == "zip":
+					packing_format = "zip"
+				else:
+					print(f"{Fore.RED}Error: Unknown format '{pack_param}'! --pack only supports '7z' or 'zip'.{Style.RESET_ALL}")
+					sys.exit(1)
+				skip_next = True
+		elif arg in ("-u", "--unlicensed"):
+			if is_next_optional_parameter(args, i):
+				keep_params = args[i+1]
+				if keep_params == "none":
+					separation_options = CategoryOption(0)
+				elif 'a' in keep_params:
+					separation_options = CategoryOption.HOMEBREW | CategoryOption.PIRATES
+				else:
+					if 'h' in keep_params:
+						separation_options |= CategoryOption.HOMEBREW
+					if 'p' in keep_params:
+						separation_options |= CategoryOption.PIRATES
+				skip_next = True
+		elif arg in ("-s", "--sort"):
+			is_sort_enabled = True
+			if is_next_optional_parameter(args, i):
+				sort_params = args[i+1]
+				if sort_params == "reverse":
+					is_reverse_sort = True
+				else:
+					if sort_params == "none":
+						sort_options = CategoryOption(0)
+					elif 'a' in sort_params:
+						sort_options = CategoryOption.HOMEBREW | CategoryOption.PIRATES | CategoryOption.SUBFOLDERS
+					else:
+						if 'h' in sort_params:
+							sort_options |= CategoryOption.HOMEBREW
+						if 'p' in sort_params:
+							sort_options |= CategoryOption.PIRATES
+						if 'f' in sort_params:
+							sort_options |= CategoryOption.SUBFOLDERS
+				skip_next = True
+		elif arg in ("-l", "--log"):
+			is_log_enabled = True
+		elif arg == "--debug":
+			is_debug_log = True
+		elif arg in ("-r", "--remove-duplicates"):
+			is_remove_duplicates = True
+			if is_next_optional_parameter(args, i):
+				remove_duplicates_param = args[i+1]
+				if remove_duplicates_param == "ask":
+					remove_duplicates_action = Action.ASK
+				elif remove_duplicates_param == "all":
+					remove_duplicates_action = Action.KEEP_ALL
+				elif remove_duplicates_param == "one":
+					remove_duplicates_action = Action.KEEP_ONE
+				else:
+					print(f"{Fore.RED}Error: Unknown action '{remove_duplicates_param}'! --remove-duplicates only supports 'ask', 'all' or 'one'.{Style.RESET_ALL}")
+					sys.exit(1)
+				skip_next = True
+		elif arg in ("-f", "--folders"):
+			if i+1 < len(args):
+				subfolders = args[i+1].split(",")
+				if is_log_enabled:
+					print("Subfolders:", subfolders)
+				skip_next = True
+			else:
+				print(f"{Fore.RED}Error: --subfolders requires a comma-separated list of subfolders.{Style.RESET_ALL}")
+				sys.exit(1)
+		elif arg in ("-e", "--exclude"):
+			if i+1 < len(args):
+				exclude_tags = args[i+1].split(",")
+				if is_log_enabled:
+					print("Exclude tags:", exclude_tags)
+				skip_next = True
+			else:
+				print(f"{Fore.RED}Error: --exclude requires a comma-separated list of tags.{Style.RESET_ALL}")
+				sys.exit(1)
+		elif arg in ("-i", "--input"):
+			if i+1 < len(args):
+				input_folder = args[i+1]
+				skip_next = True
+			else:
+				print(f"{Fore.RED}Error: --input requires a folder path.{Style.RESET_ALL}")
+				sys.exit(1)
+				
+	# Set default action for duplicates removal
+	if remove_duplicates_action == Action.NOT_DEFINED:
+		remove_duplicates_action = Action.ASK if is_log_enabled else Action.KEEP_ALL
+
+	# Check for conflicting options
+	if is_unpacking_enabled is True and is_packing_enabled is True:
+		print(f"{Fore.RED}Error: You cannot --extract and --pack at the same time.{Style.RESET_ALL}")
+		sys.exit(1)
+
+	if (is_sort_enabled is False
+			and is_unpacking_enabled is False
+			and is_packing_enabled is False
+			and is_remove_duplicates is False):
+		print(f"{Fore.YELLOW}Nothing to do...{Style.RESET_ALL}")
+		sys.exit()
+
+	if not os.path.exists(input_folder):
+		print(f"{Fore.RED}Error: The specified input folder '{input_folder}' does not exist.{Style.RESET_ALL}")
+		sys.exit(1)
+	os.chdir(input_folder)
+	print(f"Current working directory set to: {os.getcwd()}")
+
+	if exclude_tags is not None and subfolders is None:
+		print(f"{Fore.YELLOW}Warning: You cannot use --exclude without --subfolders. Option ignored.{Style.RESET_ALL}")
+
+	# Get files list
+	files_list = glob.glob("**/*.*", recursive=True)
+
+	# If duplicates removal is enabled, do it first
+	if is_remove_duplicates:
+		files_was = len(files_list)
+		files_list = clean_duplicates(files_list, remove_duplicates_action, is_log_enabled, is_debug_log)
+		if files_was != len(files_list):
+			print(f"Total ROMs left after duplicates removal: {Fore.GREEN}{len(files_list)}{Style.RESET_ALL} "
+				  f"out of {Fore.RED}{files_was}{Style.RESET_ALL}")
+		else:
+			print("No duplicates found...")
+		
+	def get_target_folder() -> str:
+		if is_sort_enabled:
+			if is_reverse_sort:
+				return '.'
+			return get_new_folder(os.path.basename(file_name), separation_options, sort_options,
+										   subfolders, exclude_tags)
+		return os.path.dirname(file_name)
+		
+	# Process files
+	if is_sort_enabled is True or is_unpacking_enabled is True or is_packing_enabled is True:
+		# Single-threaded processing for just a move operation
+		if not is_unpacking_enabled and not is_packing_enabled:
+			print(">> Processing files...")
+			progress = files_list if is_log_enabled else tqdm(files_list, desc="Processing")
+			
+			for file_name in progress:
+				target_folder = get_target_folder()
+				shutil.move(file_name, os.path.join(target_folder, os.path.basename(str(file_name))))
+				if is_log_enabled:
+					print(f" >> Moved to: {Fore.BLUE}{target_folder}{Style.RESET_ALL}")
+		else:
+			# Multithreaded processing for packing/unpacking
+			print(">> Preparing processing...")
+			tasks = []
+			for file_name in files_list:
+				target_folder = get_target_folder()
+				tasks.append((file_name, target_folder, is_unpacking_enabled, is_packing_enabled, packing_format))
+				
+			print(">> Processing files...")
+			i = 0
+			if is_log_enabled:
+				with Pool(processes=os.cpu_count()) as pool:
+					for task in pool.imap_unordered(process_file, tasks):
+						i += 1
+						f_name, result_log = task
+						print(f"({i}/{len(tasks)}) Processed: {Fore.GREEN}{f_name}{Style.RESET_ALL}")
+						if result_log is not None:
+							print(result_log)
+			else:
+				with Pool(processes=os.cpu_count()) as pool:
+					with tqdm(total=len(tasks), desc="Processing") as progress:
+						for _ in pool.imap_unordered(process_file, tasks):
+							progress.update(1)
+					
+	
+		remove_meta_files(".", is_log_enabled)
+		remove_empty_subfolders(".", is_log_enabled)
+
+	print(">> DONE!")
+	sys.exit()
+
+if __name__ == "__main__":
+	freeze_support()
+	mane()