v1.2.0

Separate comicapi into it's own package
Add support for tar files
Insert standard gitignore
Use suggested _version from setuptools-scm
Cleanup setup.py

Fix formatting in the rename template help

.github/workflows/build.yaml

@@ -1,95 +0,0 @@
-name: CI
-
-env:
-  PKG_CONFIG_PATH: /usr/local/opt/icu4c/lib/pkgconfig
-  LC_COLLATE: en_US.UTF-8
-on:
-  pull_request:
-  push:
-    branches:
-      - '**'
-    tags-ignore:
-      - '**'
-jobs:
-  lint:
-    permissions:
-      checks: write
-      contents: read
-      pull-requests: write
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        python-version: [3.9]
-        os: [ubuntu-latest]
-
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v3
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Install build dependencies
-        run: |
-          python -m pip install flake8
-
-      - uses: reviewdog/action-setup@v1
-        with:
-          reviewdog_version: nightly
-      - run: flake8 | reviewdog -f=flake8 -reporter=github-pr-review -tee -level=error -fail-on-error
-        env:
-          REVIEWDOG_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  build-and-test:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        python-version: [3.9]
-        os: [ubuntu-latest, macos-10.15, windows-latest]
-
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v3
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Install tox
-        run: |
-          python -m pip install --upgrade --upgrade-strategy eager tox
-
-      - name: Install macos dependencies
-        run: |
-          brew install icu4c pkg-config
-          # export PKG_CONFIG_PATH="/usr/local/opt/icu4c/lib/pkgconfig";
-          # export PATH="/usr/local/opt/icu4c/bin:/usr/local/opt/icu4c/sbin:$PATH"
-        if: runner.os == 'macOS'
-
-      - name: Install linux dependencies
-        run: |
-          sudo apt-get install pkg-config libicu-dev libqt5gui5 libfuse2
-          # export PKG_CONFIG_PATH="/usr/local/opt/icu4c/lib/pkgconfig";
-          # export PATH="/usr/local/opt/icu4c/bin:/usr/local/opt/icu4c/sbin:$PATH"
-        if: runner.os == 'Linux'
-
-      - name: Build and install PyPi packages
-        run: |
-          python -m tox r -m build
-
-      - name: Archive production artifacts
-        uses: actions/upload-artifact@v3
-        with:
-          name: "${{ format('ComicTagger-{0}', runner.os) }}"
-          path: |
-            dist/*.zip
-            dist/*.AppImage
-
-      - name: PyTest
-        run: |
-          python -m tox r

.github/workflows/contributions.yaml

@@ -1,43 +0,0 @@
-name: Contributions
-on:
-  push:
-    branches:
-      - 'develop'
-    tags-ignore:
-      - '**'
-
-jobs:
-  contrib-readme-job:
-    permissions:
-      contents: write
-    runs-on: ubuntu-latest
-    env:
-      CI_COMMIT_AUTHOR: github-actions[bot]
-      CI_COMMIT_EMAIL: <41898282+github-actions[bot]@users.noreply.github.com>
-      CI_COMMIT_MESSAGE: Update AUTHORS
-    name: A job to automate contrib in readme
-    steps:
-      - name: Contribute List
-        uses: akhilmhdh/contributors-readme-action@v2.3.6
-        with:
-          use_username: true
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Update AUTHORS
-        run: |
-          git config --global log.mailmap true
-          git log --reverse '--format=%aN <%aE>' | cat -n | sort -uk2 | sort -n | cut -f2- >AUTHORS
-
-      - name: Commit and push AUTHORS
-        run: |
-          if ! git diff --exit-code; then
-            git pull
-            git config --global user.name "${{ env.CI_COMMIT_AUTHOR }}"
-            git config --global user.email "${{ env.CI_COMMIT_EMAIL }}"
-            git commit -a -m "${{ env.CI_COMMIT_MESSAGE }}"
-            git push
-          fi

.github/workflows/package.yaml

@@ -1,74 +0,0 @@
-name: Package
-
-env:
-  PKG_CONFIG_PATH: /usr/local/opt/icu4c/lib/pkgconfig
-  LC_COLLATE: en_US.UTF-8
-on:
-  push:
-    tags:
-      - "[0-9]+.[0-9]+.[0-9]+*"
-jobs:
-  package:
-    permissions:
-      contents: write
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        python-version: [3.9]
-        os: [ubuntu-latest, macos-10.15, windows-latest]
-
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v3
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Install tox
-        run: |
-          python -m pip install --upgrade --upgrade-strategy eager tox
-
-      - name: Install macos dependencies
-        run: |
-          brew install icu4c pkg-config
-          # export PKG_CONFIG_PATH="/usr/local/opt/icu4c/lib/pkgconfig";
-          # export PATH="/usr/local/opt/icu4c/bin:/usr/local/opt/icu4c/sbin:$PATH"
-        if: runner.os == 'macOS'
-
-      - name: Install linux dependencies
-        run: |
-          sudo apt-get install pkg-config libicu-dev libqt5gui5
-          # export PKG_CONFIG_PATH="/usr/local/opt/icu4c/lib/pkgconfig";
-          # export PATH="/usr/local/opt/icu4c/bin:/usr/local/opt/icu4c/sbin:$PATH"
-        if: runner.os == 'Linux'
-
-      - name: Build, Install and Test PyPi packages
-        run: |
-          python -m tox r
-          python -m tox r -m release
-        env:
-          TWINE_USERNAME: __token__
-          TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
-
-      - name: Get release name
-        if: startsWith(github.ref, 'refs/tags/')
-        shell: bash
-        run: |
-          git fetch --depth=1 origin +refs/tags/*:refs/tags/* # github is dumb
-          echo "release_name=$(git tag -l --format "%(refname:strip=2): %(contents:lines=1)" ${{ github.ref_name }})" >> $GITHUB_ENV
-
-      - name: Release
-        uses: softprops/action-gh-release@v1
-        if: startsWith(github.ref, 'refs/tags/')
-        with:
-          name: "${{ env.release_name }}"
-          prerelease: "${{ contains(github.ref, '-') }}" # alpha-releases should be 1.3.0-alpha.x full releases should be 1.3.0
-          draft: false
-          # upload the single application zip file for each OS and include the wheel built on linux
-          files: |
-            dist/*.zip
-            dist/*${{ fromJSON('["never", ""]')[runner.os == 'Linux'] }}.whl
-            dist/*.AppImage

.gitignore

@@ -1,6 +1,3 @@
-# generated by setuptools_scm
-ctversion.py
-
 # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion
 
 *.iml
@@ -155,6 +152,3 @@ dmypy.json
 
 # Cython debug symbols
 cython_debug/
-
-# for testing
-temp/

.mailmap

@@ -1,9 +0,0 @@
-Andrew W. Buchanan <buchanan@difference.com>
-Davide Romanini <d.romanini@cineca.it> <davide.romanini@gmail.com>
-Davide Romanini <d.romanini@cineca.it> <user159033@92-63-141-211.rdns.melbourne.co.uk>
-Michael Fitzurka <MichaelFitzurka@users.noreply.github.com> <MichaelFitzurka@github.com>
-Timmy Welch <timmy@narnian.us>
-beville <beville@users.noreply.github.com> <(no author)@6c5673fe-1810-88d6-992b-cd32ca31540c>
-beville <beville@users.noreply.github.com> <beville@6c5673fe-1810-88d6-992b-cd32ca31540c>
-beville <beville@users.noreply.github.com> <beville@gmail.com@6c5673fe-1810-88d6-992b-cd32ca31540c>
-beville <beville@users.noreply.github.com> <beville@users.noreply.github.com>

.pre-commit-config.yaml

@@ -1,46 +0,0 @@
-exclude: ^scripts
-repos:
--   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
-    hooks:
-    -   id: trailing-whitespace
-    -   id: end-of-file-fixer
-    -   id: check-yaml
-    -   id: debug-statements
-    -   id: name-tests-test
-    -   id: requirements-txt-fixer
--   repo: https://github.com/asottile/setup-cfg-fmt
-    rev: v2.2.0
-    hooks:
-    -   id: setup-cfg-fmt
--   repo: https://github.com/PyCQA/autoflake
-    rev: v2.0.1
-    hooks:
-    -   id: autoflake
-        args: [-i, --remove-all-unused-imports, --ignore-init-module-imports]
--   repo: https://github.com/asottile/pyupgrade
-    rev: v3.3.1
-    hooks:
-    -   id: pyupgrade
-        args: [--py39-plus]
--   repo: https://github.com/PyCQA/isort
-    rev: 5.12.0
-    hooks:
-    -   id: isort
-        args: [--af,--add-import, 'from __future__ import annotations']
--   repo: https://github.com/psf/black
-    rev: 23.1.0
-    hooks:
-    -   id: black
--   repo: https://github.com/PyCQA/flake8
-    rev: 6.0.0
-    hooks:
-    -   id: flake8
-        additional_dependencies: [flake8-encodings, flake8-warnings, flake8-builtins, flake8-length, flake8-print]
--   repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v0.991
-    hooks:
-    -   id: mypy
-        additional_dependencies: [types-setuptools, types-requests]
-ci:
-    skip: [mypy]

AUTHORS

@@ -1,16 +0,0 @@
-beville <beville@users.noreply.github.com>
-Davide Romanini <d.romanini@cineca.it>
-fcanc <f.canc@icloud.com>
-Alban Seurat <alkpone@alkpone.com>
-tlc <tlc@users.noreply.github.com>
-Marek Pawlak <francuz14@gmail.com>
-Timmy Welch <timmy@narnian.us>
-J.P. Cranford <philipcranford4@gmail.com>
-thFrgttn <39759781+thFrgttn@users.noreply.github.com>
-Andrew W. Buchanan <buchanan@difference.com>
-Michael Fitzurka <MichaelFitzurka@users.noreply.github.com>
-Richard Haussmann <richard.haussmann@gmail.com>
-Mizaki <jinxybob@hotmail.com>
-Xavier Jouvenot <x.jouvenot@gmail.com>
-github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
-Ben Longman <deck@steamdeck.lan>

CONTRIBUTING.md

@@ -1,98 +0,0 @@
-# How to contribute
-
-If your not sure what you can do or you need to ask a question or just want to talk about ComicTagger head over to the [discussions tab](https://github.com/comictagger/comictagger/discussions/categories/general) and start a discussion
-
-## Tests
-
-We have tests written using pytest! Some of them even pass! If you are contributing code any tests you can write are appreciated.
-
-A great place to start is extending the tests that are already made.
-
-For example the file tests/filenames.py has lists of filenames to be parsed in the format:
-```py
-    pytest.param(
-        "Star Wars - War of the Bounty Hunters - IG-88 (2021) (Digital) (Kileko-Empire).cbz",
-        "number ends series, no-issue",
-        {
-            "issue": "",
-            "series": "Star Wars - War of the Bounty Hunters - IG-88",
-            "volume": "",
-            "year": "2021",
-            "remainder": "(Digital) (Kileko-Empire)",
-            "issue_count": "",
-        },
-        marks=pytest.mark.xfail,
-    )
-```
-
-A test consists of 3-4 parts
-1. The filename to be parsed
-2. The reason it might fail
-3. What the result of parsing the filename should be
-4. `marks=pytest.mark.xfail` This marks the test as expected to fail
-
-If you are not comfortable creating a pull request you can [open an issue](https://github.com/comictagger/comictagger/issues/new/choose) or [start a discussion](https://github.com/comictagger/comictagger/discussions/new)
-
-## Submitting changes
-
-Please open a [GitHub Pull Request](https://github.com/comictagger/comictagger/pull/new/develop) with a clear list of what you've done (read more about [pull requests](http://help.github.com/pull-requests/)). When you send a pull request, we will love you forever if you include tests. We can always use more test coverage. Please run the code tools below and make sure all of your commits are atomic (one feature per commit).
-
-## Contributing Code
-
-Currently only python 3.9 is supported however 3.10 will probably work if you try it
-
-Those on linux should install `Pillow` from the system package manager if possible and if the GUI `pyqt5` should be installed from the system package manager
-
-Those on macOS will need to ensure that you are using python3 in x86 mode either by installing an x86 only version of python or using the universal installer and using `python3-intel64` instead of `python3`
-
-1. Clone the repository
-```
-git clone https://github.com/comictagger/comictagger.git
-```
-
-2. It is preferred to use a virtual env for running from source:
-
-```
-python3 -m venv venv
-```
-
-3. Activate the virtual env:
-```
-. venv/bin/activate
-```
-or if on windows PowerShell
-```
-. venv/bin/activate.ps1
-```
-
-4. Install tox:
-```bash
-pip install tox
-```
-
-5. If you are on an M1 Mac you will need to export two environment variables for tests to pass.
-```
-export tox_python=python3.9-intel64
-export tox_env=m1env
-```
-
-6. install ComicTagger
-```
-tox run -e venv
-```
-
-7. Make your changes
-8. Build to ensure that your changes work: this will produce a binary build in the dist folder
-```bash
-tox run -m build
-```
-
-The build runs these formatters and linters automatically
-
-setup-cfg-fmt: Formats the setup.cfg file
-autoflake: Removes unused imports
-isort: sorts imports so that you can always find where an import is located<br>
-black: formats all of the code consistently so there are no surprises<br>
-flake8: checks for code quality and style (warns for unused imports and similar issues)<br>
-mypy: checks the types of variables and functions to catch errors
-pytest: runs tests for ComicTagger functionality

Makefile

@@ -0,0 +1,46 @@
+VERSION_STR := $(shell python -c 'import comictaggerlib._version; print( comictaggerlib._version.version)')
+
+ifeq ($(OS),Windows_NT)
+	APP_NAME=comictagger.exe
+	FINAL_NAME=ComicTagger-$(VERSION_STR).exe
+	ICON_PATH="windows/app.ico"
+else ifeq ($(shell uname -s),Darwin)
+	APP_NAME=ComicTagger.app
+	FINAL_NAME=ComicTagger-$(VERSION_STR).app
+	ICON_PATH="mac/app.icns"
+else
+	APP_NAME=comictagger
+	FINAL_NAME=ComicTagger-$(VERSION_STR)
+	ICON_PATH="windows/app.ico"
+endif
+
+.PHONY: all clean pydist upload dist
+	
+all: clean dist
+
+clean:
+	rm -rf *~ *.pyc *.pyo
+	rm -rf scripts/*.pyc
+	cd comictaggerlib; rm -f *~ *.pyc *.pyo
+	rm -rf dist MANIFEST
+	rm -rf *.deb
+	rm -rf logdict*.log
+	$(MAKE) -C mac clean   
+	rm -rf build
+	rm -rf comictaggerlib/ui/__pycache__
+
+pydist:
+	make clean
+	mkdir -p piprelease
+	rm -f comictagger-$(VERSION_STR).zip
+	python setup.py sdist --formats=zip  #,gztar
+	mv dist/comictagger-$(VERSION_STR).zip piprelease
+	rm -rf comictagger.egg-info dist
+		
+upload:
+	python setup.py register
+	python setup.py sdist --formats=zip upload
+
+dist:
+	pyinstaller.exe --name="comictagger" --windowed --add-data 'comictaggerlib/ui/*.ui;ui' --add-data 'comictaggerlib/graphics;graphics' -i windows/app.ico --version-file file_version_info.py comictagger.py
+	mv dist/$(APP_NAME) dist/$(FINAL_NAME)

README.md

@@ -1,178 +1,16 @@
-[![CI](https://github.com/comictagger/comictagger/actions/workflows/build.yaml/badge.svg?branch=develop&event=push)](https://github.com/comictagger/comictagger/actions/workflows/build.yaml)
-[![GitHub release (latest by date)](https://img.shields.io/github/downloads/comictagger/comictagger/latest/total)](https://github.com/comictagger/comictagger/releases/latest)
-[![PyPI](https://img.shields.io/pypi/v/comictagger)](https://pypi.org/project/comictagger/)
-[![PyPI - Downloads](https://img.shields.io/pypi/dm/comictagger)](https://pypistats.org/packages/comictagger)
-[![Chocolatey package](https://img.shields.io/chocolatey/dt/comictagger?color=blue&label=chocolatey)](https://community.chocolatey.org/packages/comictagger)
-[![PyPI - License](https://img.shields.io/pypi/l/comictagger)](https://opensource.org/licenses/Apache-2.0)
-
-[![GitHub Discussions](https://img.shields.io/github/discussions/comictagger/comictagger)](https://github.com/comictagger/comictagger/discussions)
-[![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/comictagger/community)
-[![Google Group](https://img.shields.io/badge/discuss-on%20groups-%23207de5)](https://groups.google.com/forum/#!forum/comictagger)
-[![Twitter](https://img.shields.io/badge/%40comictagger-twitter-lightgrey)](https://twitter.com/comictagger)
-[![Facebook](https://img.shields.io/badge/comictagger-facebook-lightgrey)](https://www.facebook.com/ComicTagger-139615369550787/)
-
-# ComicTagger
-
-ComicTagger is a **multi-platform** app for **writing metadata to digital comics**, written in Python and PyQt.
-
-![ComicTagger logo](https://raw.githubusercontent.com/comictagger/comictagger/develop/comictaggerlib/graphics/app.png)
-
-## Features
-
-* Runs on macOS, Microsoft Windows, and Linux systems
-* Get comic information from [Comic Vine](https://comicvine.gamespot.com/)
-* **Automatic issue matching** using advanced image processing techniques
-* **Batch processing** in the GUI for tagging hundreds or more comics at a time
-* Support for **ComicRack** and **ComicBookLover** tagging formats
-* Native full support for **CBZ** digital comics
-* Native read only support for **CBR** digital comics: full support enabled installing additional [rar tools](https://www.rarlab.com/download.htm)
-* Command line interface (CLI) enabling **custom scripting** and **batch operations on large collections**
-
-For details, screen-shots, and more, visit [the Wiki](https://github.com/comictagger/comictagger/wiki)
-
-
-## Installation
-
-### Binaries
-
-Windows, Linux and MacOS binaries are provided in the [Releases Page](https://github.com/comictagger/comictagger/releases).
-
-Just unzip the archive in any folder and run, no additional installation steps are required.
-
-### PIP installation
-
-A pip package is provided, you can install it with:
-
-```
- $ pip3 install comictagger[GUI]
-```
-
-There are optional dependencies. You can install the optional dependencies by specifying one or more of them in braces e.g. `comictagger[CBR,GUI]`
-
-Optional dependencies:
-1. `ICU`: Ensures that comic pages are supported correctly. This should always be installed. *Currently only exists in the latest alpha release *
-1. `CBR`: Provides support for CBR/RAR files.
-1. `GUI`: Installs the GUI.
-1. `7Z`: Provides support for CB7/7Z files.
-1. `all`: Installs all of the above optional dependencies.
-
-### Chocolatey installation (Windows only)
-
-A [Chocolatey package](https://community.chocolatey.org/packages/comictagger), maintained by @Xav83, is provided, you can install it with:
-```powershell
-choco install comictagger
-```
-### From source
-
- 1. Ensure you have python 3.9 installed
- 2. Clone this repository `git clone https://github.com/comictagger/comictagger.git`
- 7. `pip3 install .[ICU]` or `pip3 install .[GUI,ICU]`
-
-
-## Contributors
-
-<!-- readme: beville,davide-romanini,collaborators,contributors -start -->
-<table>
-<tr>
-    <td align="center">
-        <a href="https://github.com/beville">
-            <img src="https://avatars.githubusercontent.com/u/7294848?v=4" width="100;" alt="beville"/>
-            <br />
-            <sub><b>beville</b></sub>
-        </a>
-    </td>
-    <td align="center">
-        <a href="https://github.com/davide-romanini">
-            <img src="https://avatars.githubusercontent.com/u/731199?v=4" width="100;" alt="davide-romanini"/>
-            <br />
-            <sub><b>davide-romanini</b></sub>
-        </a>
-    </td>
-    <td align="center">
-        <a href="https://github.com/fcanc">
-            <img src="https://avatars.githubusercontent.com/u/4999486?v=4" width="100;" alt="fcanc"/>
-            <br />
-            <sub><b>fcanc</b></sub>
-        </a>
-    </td>
-    <td align="center">
-        <a href="https://github.com/lordwelch">
-            <img src="https://avatars.githubusercontent.com/u/7547075?v=4" width="100;" alt="lordwelch"/>
-            <br />
-            <sub><b>lordwelch</b></sub>
-        </a>
-    </td>
-    <td align="center">
-        <a href="https://github.com/mizaki">
-            <img src="https://avatars.githubusercontent.com/u/1141189?v=4" width="100;" alt="mizaki"/>
-            <br />
-            <sub><b>mizaki</b></sub>
-        </a>
-    </td>
-    <td align="center">
-        <a href="https://github.com/MichaelFitzurka">
-            <img src="https://avatars.githubusercontent.com/u/27830765?v=4" width="100;" alt="MichaelFitzurka"/>
-            <br />
-            <sub><b>MichaelFitzurka</b></sub>
-        </a>
-    </td></tr>
-<tr>
-    <td align="center">
-        <a href="https://github.com/abuchanan920">
-            <img src="https://avatars.githubusercontent.com/u/368793?v=4" width="100;" alt="abuchanan920"/>
-            <br />
-            <sub><b>abuchanan920</b></sub>
-        </a>
-    </td>
-    <td align="center">
-        <a href="https://github.com/AlbanSeurat">
-            <img src="https://avatars.githubusercontent.com/u/500180?v=4" width="100;" alt="AlbanSeurat"/>
-            <br />
-            <sub><b>AlbanSeurat</b></sub>
-        </a>
-    </td>
-    <td align="center">
-        <a href="https://github.com/rhaussmann">
-            <img src="https://avatars.githubusercontent.com/u/7084007?v=4" width="100;" alt="rhaussmann"/>
-            <br />
-            <sub><b>rhaussmann</b></sub>
-        </a>
-    </td>
-    <td align="center">
-        <a href="https://github.com/jpcranford">
-            <img src="https://avatars.githubusercontent.com/u/21347202?v=4" width="100;" alt="jpcranford"/>
-            <br />
-            <sub><b>jpcranford</b></sub>
-        </a>
-    </td>
-    <td align="center">
-        <a href="https://github.com/PawlakMarek">
-            <img src="https://avatars.githubusercontent.com/u/26022173?v=4" width="100;" alt="PawlakMarek"/>
-            <br />
-            <sub><b>PawlakMarek</b></sub>
-        </a>
-    </td>
-    <td align="center">
-        <a href="https://github.com/Xav83">
-            <img src="https://avatars.githubusercontent.com/u/6787157?v=4" width="100;" alt="Xav83"/>
-            <br />
-            <sub><b>Xav83</b></sub>
-        </a>
-    </td></tr>
-<tr>
-    <td align="center">
-        <a href="https://github.com/thFrgttn">
-            <img src="https://avatars.githubusercontent.com/u/39759781?v=4" width="100;" alt="thFrgttn"/>
-            <br />
-            <sub><b>thFrgttn</b></sub>
-        </a>
-    </td>
-    <td align="center">
-        <a href="https://github.com/tlc">
-            <img src="https://avatars.githubusercontent.com/u/19436?v=4" width="100;" alt="tlc"/>
-            <br />
-            <sub><b>tlc</b></sub>
-        </a>
-    </td></tr>
-</table>
-<!-- readme: beville,davide-romanini,collaborators,contributors -end -->
+A fork from https://github.com/comictagger/comictagger
+
+Changes:
+ - switched to rarfile, makes dependencies simpler and I had issues using unrar-cffi with python<6.7
+ - Move to Python requests module, requests is much simpler and fixes all ssl errors.
+ - Moved to using Python format strings and use pathvalidate to handle filenames, supports directory structures
+ - Issue string parsing now strips off (# of #) (e.g. 1 of 45)
+ - Add publisher and imprint handling, currently hardcoded
+ 
+Notes:
+- I did some testing with the pyinstaller build, and it worked on both platforms.  I did encounter two problems:
+  - Mac build showed the wrong widget set. I found a solution here that seemed to work: https://stackoverflow.com/questions/48626999/packaging-with-pyinstaller-pyqt5-setstyle-ignored
+  - Windows build had problems grabbing images from ComicVine using SSL.  It think that some libraries are missing from the monolithic exe, but I couldn't figure out how to fix the problem. 
+- In setup.py you can also find the remains of an attempt to do some desktop integration from a pip install.  It does work, but can cause problems with wheel installs, and I don't know if it's worth the bother.  I kept the commented-out code in place, just in case.
+
+With Python 3, it's much easier to get the app working from scratch on a new distro, as all of the dependencies are available as wheels, including PyQt5, so just a simple "pip install comictagger.zip" is all that's needed.

appveyor.yml

@@ -0,0 +1,6 @@
+version: 1.0.{build}
+build_script:
+- cmd: powershell -exec bypass -File windows\fullbuild.ps1
+artifacts:
+- path: dist\*.exe
+  name: ComicTagger

build-tools/comictagger.spec

@@ -1,241 +0,0 @@
-# -*- mode: python ; coding: utf-8 -*-
-
-import platform
-
-from comictaggerlib import ctversion
-
-enable_console = False
-block_cipher = None
-
-
-a = Analysis(
-    ["../comictaggerlib/__main__.py"],
-    pathex=[],
-    binaries=[],
-    datas=[],
-    hiddenimports=[],
-    hookspath=[],
-    hooksconfig={},
-    runtime_hooks=[],
-    excludes=[],
-    win_no_prefer_redirects=False,
-    win_private_assemblies=False,
-    cipher=block_cipher,
-    noarchive=False,
-)
-
-exe_binaries = []
-exe_zipfiles = []
-exe_datas = []
-exe_exclude_binaries = True
-
-coll_binaries = a.binaries
-coll_zipfiles = a.zipfiles
-coll_datas = a.datas
-
-if platform.system() in ["Windows"]:
-    enable_console = True
-    exe_binaries = a.binaries
-    exe_zipfiles = a.zipfiles
-    exe_datas = a.datas
-    exe_exclude_binaries = False
-
-    coll_binaries = []
-    coll_zipfiles = []
-    coll_datas = []
-
-
-pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher)
-
-exe = EXE(
-    pyz,
-    a.scripts,
-    exe_binaries,
-    exe_zipfiles,
-    exe_datas,
-    [],
-    exclude_binaries=exe_exclude_binaries,
-    name="comictagger",
-    debug=False,
-    bootloader_ignore_signals=False,
-    strip=False,
-    upx=True,
-    upx_exclude=[],
-    runtime_tmpdir=None,
-    console=enable_console,
-    disable_windowed_traceback=False,
-    argv_emulation=False,
-    target_arch=None,
-    codesign_identity=None,
-    entitlements_file=None,
-    icon="windows/app.ico",
-)
-if platform.system() not in ["Windows"]:
-    coll = COLLECT(
-        exe,
-        coll_binaries,
-        coll_zipfiles,
-        coll_datas,
-        strip=False,
-        upx=True,
-        upx_exclude=[],
-        name="comictagger",
-    )
-    app = BUNDLE(
-        coll,
-        name="ComicTagger.app",
-        icon="mac/app.icns",
-        info_plist={
-            "NSHighResolutionCapable": "True",
-            "NSPrincipalClass": "NSApplication",
-            "NSRequiresAquaSystemAppearance": "False",
-            "CFBundleDisplayName": "ComicTagger",
-            "CFBundleShortVersionString": ctversion.version,
-            "CFBundleVersion": ctversion.version,
-            "CFBundleDocumentTypes": [
-                {
-                    "CFBundleTypeRole": "Editor",
-                    "LSHandlerRank": "Default",
-                    "LSItemContentTypes": [
-                        "public.folder",
-                    ],
-                    "CFBundleTypeName": "Folder",
-                },
-                {
-                    "CFBundleTypeExtensions": [
-                        "cbz",
-                    ],
-                    "LSTypeIsPackage": False,
-                    "NSPersistentStoreTypeKey": "Binary",
-                    "CFBundleTypeIconSystemGenerated": True,
-                    "CFBundleTypeName": "ZIP Comic Archive",
-                    "LSItemContentTypes": [
-                        "public.zip-comic-archive",
-                        "com.simplecomic.cbz-archive",
-                        "com.macitbetter.cbz-archive",
-                        "public.cbz-archive",
-                        "cx.c3.cbz-archive",
-                        "com.yacreader.yacreader.cbz",
-                        "com.milke.cbz-archive",
-                        "com.bitcartel.comicbooklover.cbz",
-                        "public.archive.cbz",
-                        "public.zip-archive",
-                    ],
-                    "CFBundleTypeRole": "Editor",
-                    "LSHandlerRank": "Default",
-                },
-                {
-                    "CFBundleTypeExtensions": [
-                        "cb7",
-                    ],
-                    "LSTypeIsPackage": False,
-                    "NSPersistentStoreTypeKey": "Binary",
-                    "CFBundleTypeIconSystemGenerated": True,
-                    "CFBundleTypeName": "7-Zip Comic Archive",
-                    "LSItemContentTypes": [
-                        "org.7-zip.7-zip-archive",
-                        "com.simplecomic.cb7-archive",
-                        "public.cb7-archive",
-                        "com.macitbetter.cb7-archive",
-                        "cx.c3.cb7-archive",
-                        "org.7-zip.7-zip-comic-archive",
-                    ],
-                    "CFBundleTypeRole": "Editor",
-                    "LSHandlerRank": "Default",
-                },
-                {
-                    "CFBundleTypeExtensions": [
-                        "cbr",
-                    ],
-                    "LSTypeIsPackage": False,
-                    "NSPersistentStoreTypeKey": "Binary",
-                    "CFBundleTypeIconSystemGenerated": True,
-                    "CFBundleTypeName": "RAR Comic Archive",
-                    "LSItemContentTypes": [
-                        "com.rarlab.rar-archive",
-                        "com.rarlab.rar-comic-archive",
-                        "com.simplecomic.cbr-archive",
-                        "com.macitbetter.cbr-archive",
-                        "public.cbr-archive",
-                        "cx.c3.cbr-archive",
-                        "com.bitcartel.comicbooklover.cbr",
-                        "com.milke.cbr-archive",
-                        "public.archive.cbr",
-                        "com.yacreader.yacreader.cbr",
-                    ],
-                    "CFBundleTypeRole": "Editor",
-                    "LSHandlerRank": "Default",
-                },
-            ],
-            "UTImportedTypeDeclarations": [
-                {
-                    "UTTypeIdentifier": "com.rarlab.rar-archive",
-                    "UTTypeDescription": "RAR Archive",
-                    "UTTypeConformsTo": [
-                        "public.data",
-                        "public.archive",
-                    ],
-                    "UTTypeTagSpecification": {
-                        "public.mime-type": [
-                            "application/x-rar",
-                            "application/x-rar-compressed",
-                        ],
-                        "public.filename-extension": [
-                            "rar",
-                        ],
-                    },
-                },
-                {
-                    "UTTypeConformsTo": [
-                        "public.data",
-                        "public.archive",
-                        "com.rarlab.rar-archive",
-                    ],
-                    "UTTypeIdentifier": "com.rarlab.rar-comic-archive",
-                    "UTTypeDescription": "RAR Comic Archive",
-                    "UTTypeTagSpecification": {
-                        "public.mime-type": [
-                            "application/vnd.comicbook-rar",
-                            "application/x-cbr",
-                        ],
-                        "public.filename-extension": [
-                            "cbr",
-                        ],
-                    },
-                },
-                {
-                    "UTTypeConformsTo": [
-                        "public.data",
-                        "public.archive",
-                        "public.zip-archive",
-                    ],
-                    "UTTypeIdentifier": "public.zip-comic-archive",
-                    "UTTypeDescription": "ZIP Comic Archive",
-                    "UTTypeTagSpecification": {
-                        "public.filename-extension": [
-                            "cbz",
-                        ],
-                    },
-                },
-                {
-                    "UTTypeConformsTo": [
-                        "public.data",
-                        "public.archive",
-                        "org.7-zip.7-zip-archive",
-                    ],
-                    "UTTypeIdentifier": "org.7-zip.7-zip-comic-archive",
-                    "UTTypeDescription": "7-Zip Comic Archive",
-                    "UTTypeTagSpecification": {
-                        "public.mime-type": [
-                            "application/vnd.comicbook+7-zip",
-                            "application/x-cb7-compressed",
-                        ],
-                        "public.filename-extension": [
-                            "cb7",
-                        ],
-                    },
-                },
-            ],
-        },
-        bundle_identifier="com.comictagger",
-    )

build-tools/get_appimage.py

@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-import os
-import pathlib
-import stat
-
-import requests
-
-
-def urlretrieve(url: str, dest: str) -> None:
-    resp = requests.get(url)
-    if resp.status_code == 200:
-        pathlib.Path(dest).write_bytes(resp.content)
-
-
-APPIMAGETOOL = "build/appimagetool-x86_64.AppImage"
-if os.path.exists(APPIMAGETOOL):
-    raise SystemExit(0)
-
-urlretrieve(
-    "https://github.com/AppImage/AppImageKit/releases/latest/download/appimagetool-x86_64.AppImage", APPIMAGETOOL
-)
-os.chmod(APPIMAGETOOL, stat.S_IRWXU)
-
-if not os.path.exists(APPIMAGETOOL):
-    raise SystemExit(1)

build-tools/zip_artifacts.py

@@ -1,47 +0,0 @@
-from __future__ import annotations
-
-import os
-import pathlib
-import platform
-import zipfile
-
-from comictaggerlib.ctversion import __version__
-
-app = "ComicTagger"
-exe = app.casefold()
-if platform.system() == "Windows":
-    os_version = f"win-{platform.machine()}"
-    app_name = f"{exe}.exe"
-    final_name = f"{app}-{__version__}-{os_version}.exe"
-elif platform.system() == "Darwin":
-    ver = platform.mac_ver()
-    os_version = f"osx-{ver[0]}-{ver[2]}"
-    app_name = f"{app}.app"
-    final_name = f"{app}-{__version__}-{os_version}.app"
-else:
-    app_name = exe
-    final_name = f"ComicTagger-{__version__}-{platform.system()}"
-
-path = f"dist/{app_name}"
-zip_file = pathlib.Path(f"dist/{final_name}.zip")
-
-
-def addToZip(zf, path, zippath):
-    if os.path.isfile(path):
-        zf.write(path, zippath)
-    elif os.path.isdir(path):
-        if zippath:
-            zf.write(path, zippath)
-        for nm in sorted(os.listdir(path)):
-            addToZip(zf, os.path.join(path, nm), os.path.join(zippath, nm))
-    # else: ignore
-
-
-zip_file.unlink(missing_ok=True)
-with zipfile.ZipFile(zip_file, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=8) as zf:
-    zippath = os.path.basename(path)
-    if not zippath:
-        zippath = os.path.basename(os.path.dirname(path))
-    if zippath in ("", os.curdir, os.pardir):
-        zippath = ""
-    addToZip(zf, path, zippath)

comicapi/__init__.py

@@ -1,3 +0,0 @@
-from __future__ import annotations
-
-__author__ = "dromanin"

comicapi/__pyinstaller/__init__.py

@@ -1,7 +0,0 @@
-from __future__ import annotations
-
-import os
-
-
-def get_hook_dirs() -> list[str]:
-    return [os.path.dirname(__file__)]

comicapi/__pyinstaller/hook-comicapi.py

@@ -1,6 +0,0 @@
-from __future__ import annotations
-
-from PyInstaller.utils.hooks import collect_data_files, collect_entry_point
-
-datas, hiddenimports = collect_entry_point("comicapi.archiver")
-datas += collect_data_files("comicapi.data")

comicapi/archivers/__init__.py

@@ -1,15 +0,0 @@
-from __future__ import annotations
-
-from comicapi.archivers.archiver import Archiver
-from comicapi.archivers.folder import FolderArchiver
-from comicapi.archivers.rar import RarArchiver
-from comicapi.archivers.sevenzip import SevenZipArchiver
-from comicapi.archivers.zip import ZipArchiver
-
-
-class UnknownArchiver(Archiver):
-    def name(self) -> str:
-        return "Unknown"
-
-
-__all__ = ["Archiver", "UnknownArchiver", "FolderArchiver", "RarArchiver", "ZipArchiver", "SevenZipArchiver"]

comicapi/archivers/archiver.py

@@ -1,130 +0,0 @@
-from __future__ import annotations
-
-import pathlib
-from typing import Protocol, runtime_checkable
-
-
-@runtime_checkable
-class Archiver(Protocol):
-
-    """Archiver Protocol"""
-
-    """The path to the archive"""
-    path: pathlib.Path
-
-    """
-    The name of the executable used for this archiver. This should be the base name of the executable.
-    For example if 'rar.exe' is needed this should be "rar".
-    If an executable is not used this should be the empty string.
-    """
-    exe: str = ""
-
-    """
-    Whether or not this archiver is enabled.
-    If external imports are required and are not available this should be false. See rar.py and sevenzip.py.
-    """
-    enabled: bool = True
-
-    def __init__(self):
-        self.path = pathlib.Path()
-
-    def get_comment(self) -> str:
-        """
-        Returns the comment from the current archive as a string.
-        Should always return a string. If comments are not supported in the archive the empty string should be returned.
-        """
-        return ""
-
-    def set_comment(self, comment: str) -> bool:
-        """
-        Returns True if the comment was successfully set on the current archive.
-        Should always return a boolean. If comments are not supported in the archive False should be returned.
-        """
-        return False
-
-    def supports_comment(self) -> bool:
-        """
-        Returns True if the current archive supports comments.
-        Should always return a boolean. If comments are not supported in the archive False should be returned.
-        """
-        return False
-
-    def read_file(self, archive_file: str) -> bytes:
-        """
-        Reads the named file from the current archive.
-        archive_file should always come from the output of get_filename_list.
-        Should always return a bytes object. Exceptions should be of the type OSError.
-        """
-        raise NotImplementedError
-
-    def remove_file(self, archive_file: str) -> bool:
-        """
-        Removes the named file from the current archive.
-        archive_file should always come from the output of get_filename_list.
-        Should always return a boolean. Failures should return False.
-
-        Rebuilding the archive without the named file is a standard way to remove a file.
-        """
-        return False
-
-    def write_file(self, archive_file: str, data: bytes) -> bool:
-        """
-        Writes the named file to the current archive.
-        Should always return a boolean. Failures should return False.
-        """
-        return False
-
-    def get_filename_list(self) -> list[str]:
-        """
-        Returns a list of filenames in the current archive.
-        Should always return a list of string. Failures should return an empty list.
-        """
-        return []
-
-    def copy_from_archive(self, other_archive: Archiver) -> bool:
-        """
-        Copies the contents of another achive to the current archive.
-        Should always return a boolean. Failures should return False.
-        """
-        return False
-
-    def is_writable(self) -> bool:
-        """
-        Retuns True if the current archive is writeable
-        Should always return a boolean. Failures should return False.
-        """
-        return False
-
-    def extension(self) -> str:
-        """
-        Returns the extension that this archiver should use eg ".cbz".
-        Should always return a string. Failures should return the empty string.
-        """
-        return ""
-
-    def name(self) -> str:
-        """
-        Returns the name of this archiver for display purposes eg "CBZ".
-        Should always return a string. Failures should return the empty string.
-        """
-        return ""
-
-    @classmethod
-    def is_valid(cls, path: pathlib.Path) -> bool:
-        """
-        Returns True if the given path can be opened by this archiver.
-        Should always return a boolean. Failures should return False.
-        """
-        return False
-
-    @classmethod
-    def open(cls, path: pathlib.Path) -> Archiver:
-        """
-        Opens the given archive.
-        Should always return a an Archver.
-        Should never cause an exception no file operations should take place in this method,
-        is_valid will always be called before open.
-        """
-        archiver = cls()
-        archiver.path = path
-        return archiver

comicapi/archivers/folder.py

@@ -1,97 +0,0 @@
-from __future__ import annotations
-
-import logging
-import os
-import pathlib
-
-from comicapi.archivers import Archiver
-
-logger = logging.getLogger(__name__)
-
-
-class FolderArchiver(Archiver):
-
-    """Folder implementation"""
-
-    def __init__(self) -> None:
-        super().__init__()
-        self.comment_file_name = "ComicTaggerFolderComment.txt"
-
-    def get_comment(self) -> str:
-        try:
-            return self.read_file(self.comment_file_name).decode("utf-8")
-        except OSError:
-            return ""
-
-    def set_comment(self, comment: str) -> bool:
-        if (self.path / self.comment_file_name).exists() or comment:
-            return self.write_file(self.comment_file_name, comment.encode("utf-8"))
-        return True
-
-    def read_file(self, archive_file: str) -> bytes:
-        try:
-            with open(self.path / archive_file, mode="rb") as f:
-                data = f.read()
-        except OSError as e:
-            logger.error("Error reading folder archive [%s]: %s :: %s", e, self.path, archive_file)
-            raise
-
-        return data
-
-    def remove_file(self, archive_file: str) -> bool:
-        try:
-            (self.path / archive_file).unlink(missing_ok=True)
-        except OSError as e:
-            logger.error("Error removing file for folder archive [%s]: %s :: %s", e, self.path, archive_file)
-            return False
-        else:
-            return True
-
-    def write_file(self, archive_file: str, data: bytes) -> bool:
-        try:
-            file_path = self.path / archive_file
-            file_path.parent.mkdir(exist_ok=True, parents=True)
-            with open(self.path / archive_file, mode="wb") as f:
-                f.write(data)
-        except OSError as e:
-            logger.error("Error writing folder archive [%s]: %s :: %s", e, self.path, archive_file)
-            return False
-        else:
-            return True
-
-    def get_filename_list(self) -> list[str]:
-        filenames = []
-        try:
-            for root, _dirs, files in os.walk(self.path):
-                for f in files:
-                    filenames.append(os.path.relpath(os.path.join(root, f), self.path).replace(os.path.sep, "/"))
-            return filenames
-        except OSError as e:
-            logger.error("Error listing files in folder archive [%s]: %s", e, self.path)
-            return []
-
-    def copy_from_archive(self, other_archive: Archiver) -> bool:
-        """Replace the current zip with one copied from another archive"""
-        try:
-            for filename in other_archive.get_filename_list():
-                data = other_archive.read_file(filename)
-                if data is not None:
-                    self.write_file(filename, data)
-
-            # preserve the old comment
-            comment = other_archive.get_comment()
-            if comment is not None:
-                if not self.set_comment(comment):
-                    return False
-        except Exception:
-            logger.exception("Error while copying archive from %s to %s", other_archive.path, self.path)
-            return False
-        else:
-            return True
-
-    def name(self) -> str:
-        return "Folder"
-
-    @classmethod
-    def is_valid(cls, path: pathlib.Path) -> bool:
-        return path.is_dir()

comicapi/archivers/rar.py

@@ -1,262 +0,0 @@
-from __future__ import annotations
-
-import logging
-import os
-import pathlib
-import platform
-import shutil
-import subprocess
-import tempfile
-import time
-
-from comicapi.archivers import Archiver
-
-try:
-    import rarfile
-
-    rar_support = True
-except ImportError:
-    rar_support = False
-
-
-logger = logging.getLogger(__name__)
-
-if not rar_support:
-    logger.error("rar unavailable")
-
-
-class RarArchiver(Archiver):
-    """RAR implementation"""
-
-    enabled = rar_support
-    exe = "rar"
-
-    def __init__(self) -> None:
-        super().__init__()
-
-        # windows only, keeps the cmd.exe from popping up
-        if platform.system() == "Windows":
-            self.startupinfo = subprocess.STARTUPINFO()  # type: ignore
-            self.startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW  # type: ignore
-        else:
-            self.startupinfo = None
-
-    def get_comment(self) -> str:
-        rarc = self.get_rar_obj()
-        return (rarc.comment if rarc else "") or ""
-
-    def set_comment(self, comment: str) -> bool:
-        if rar_support and self.exe:
-            try:
-                # write comment to temp file
-                with tempfile.TemporaryDirectory() as tmp_dir:
-                    tmp_file = pathlib.Path(tmp_dir) / "rar_comment.txt"
-                    tmp_file.write_text(comment, encoding="utf-8")
-
-                    working_dir = os.path.dirname(os.path.abspath(self.path))
-
-                    # use external program to write comment to Rar archive
-                    proc_args = [
-                        self.exe,
-                        "c",
-                        f"-w{working_dir}",
-                        "-c-",
-                        f"-z{tmp_file}",
-                        str(self.path),
-                    ]
-                    subprocess.run(
-                        proc_args,
-                        startupinfo=self.startupinfo,
-                        stdout=subprocess.DEVNULL,
-                        stdin=subprocess.DEVNULL,
-                        stderr=subprocess.DEVNULL,
-                        check=True,
-                    )
-
-                if platform.system() == "Darwin":
-                    time.sleep(1)
-            except (subprocess.CalledProcessError, OSError) as e:
-                logger.exception("Error writing comment to rar archive [%s]: %s", e, self.path)
-                return False
-            else:
-                return True
-        else:
-            return False
-
-    def read_file(self, archive_file: str) -> bytes:
-        rarc = self.get_rar_obj()
-        if rarc is None:
-            return b""
-
-        tries = 0
-        while tries < 7:
-            try:
-                tries = tries + 1
-                data: bytes = rarc.open(archive_file).read()
-                entries = [(rarc.getinfo(archive_file), data)]
-
-                if entries[0][0].file_size != len(entries[0][1]):
-                    logger.info(
-                        "Error reading rar archive [file is not expected size: %d vs %d]  %s :: %s :: tries #%d",
-                        entries[0][0].file_size,
-                        len(entries[0][1]),
-                        self.path,
-                        archive_file,
-                        tries,
-                    )
-                    continue
-
-            except OSError as e:
-                logger.error("Error reading rar archive [%s]: %s :: %s :: tries #%d", e, self.path, archive_file, tries)
-                time.sleep(1)
-            except Exception as e:
-                logger.error(
-                    "Unexpected exception reading rar archive [%s]: %s :: %s :: tries #%d",
-                    e,
-                    self.path,
-                    archive_file,
-                    tries,
-                )
-                break
-
-            else:
-                # Success. Entries is a list of of tuples:  ( rarinfo, filedata)
-                if len(entries) == 1:
-                    return entries[0][1]
-
-                raise OSError
-
-        raise OSError
-
-    def remove_file(self, archive_file: str) -> bool:
-        if self.exe:
-            # use external program to remove file from Rar archive
-            result = subprocess.run(
-                [self.exe, "d", "-c-", self.path, archive_file],
-                startupinfo=self.startupinfo,
-                stdout=subprocess.DEVNULL,
-                stdin=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-            )
-
-            if platform.system() == "Darwin":
-                time.sleep(1)
-            if result.returncode != 0:
-                logger.error(
-                    "Error removing file from rar archive [exitcode: %d]: %s :: %s",
-                    result.returncode,
-                    self.path,
-                    archive_file,
-                )
-                return False
-            return True
-        else:
-            return False
-
-    def write_file(self, archive_file: str, data: bytes) -> bool:
-        if self.exe:
-            archive_path = pathlib.PurePosixPath(archive_file)
-            archive_name = archive_path.name
-            archive_parent = str(archive_path.parent).lstrip("./")
-
-            # use external program to write file to Rar archive
-            result = subprocess.run(
-                [self.exe, "a", f"-si{archive_name}", f"-ap{archive_parent}", "-c-", "-ep", self.path],
-                input=data,
-                startupinfo=self.startupinfo,
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-            )
-
-            if platform.system() == "Darwin":
-                time.sleep(1)
-            if result.returncode != 0:
-                logger.error(
-                    "Error writing rar archive [exitcode: %d]: %s :: %s", result.returncode, self.path, archive_file
-                )
-                return False
-            else:
-                return True
-        else:
-            return False
-
-    def get_filename_list(self) -> list[str]:
-        rarc = self.get_rar_obj()
-        tries = 0
-        if rar_support and rarc:
-            while tries < 7:
-                try:
-                    tries = tries + 1
-                    namelist = []
-                    for item in rarc.infolist():
-                        if item.file_size != 0:
-                            namelist.append(item.filename)
-
-                except OSError as e:
-                    logger.error("Error listing files in rar archive [%s]: %s :: attempt #%d", e, self.path, tries)
-                    time.sleep(1)
-
-                else:
-                    return namelist
-        return []
-
-    def copy_from_archive(self, other_archive: Archiver) -> bool:
-        """Replace the current archive with one copied from another archive"""
-        try:
-            with tempfile.TemporaryDirectory() as tmp_dir:
-                tmp_path = pathlib.Path(tmp_dir)
-                rar_cwd = tmp_path / "rar"
-                rar_cwd.mkdir(exist_ok=True)
-                rar_path = (tmp_path / self.path.name).with_suffix(".rar")
-
-                for filename in other_archive.get_filename_list():
-                    (rar_cwd / filename).parent.mkdir(exist_ok=True, parents=True)
-                    data = other_archive.read_file(filename)
-                    if data is not None:
-                        with open(rar_cwd / filename, mode="w+b") as tmp_file:
-                            tmp_file.write(data)
-                result = subprocess.run(
-                    [self.exe, "a", "-r", "-c-", str(rar_path.absolute()), "."],
-                    cwd=rar_cwd.absolute(),
-                    startupinfo=self.startupinfo,
-                    stdout=subprocess.DEVNULL,
-                    stdin=subprocess.DEVNULL,
-                    stderr=subprocess.DEVNULL,
-                )
-                if result.returncode != 0:
-                    logger.error("Error while copying to rar archive [exitcode: %d]: %s", result.returncode, self.path)
-                    return False
-
-                self.path.unlink(missing_ok=True)
-                shutil.move(rar_path, self.path)
-        except Exception as e:
-            logger.exception("Error while copying to rar archive [%s]: from %s to %s", e, other_archive.path, self.path)
-            return False
-        else:
-            return True
-
-    def is_writable(self) -> bool:
-        return bool(self.exe and (os.path.exists(self.exe) or shutil.which(self.exe)))
-
-    def extension(self) -> str:
-        return ".cbr"
-
-    def name(self) -> str:
-        return "RAR"
-
-    @classmethod
-    def is_valid(cls, path: pathlib.Path) -> bool:
-        if rar_support:
-            return rarfile.is_rarfile(str(path))
-        return False
-
-    def get_rar_obj(self) -> rarfile.RarFile | None:
-        if rar_support:
-            try:
-                rarc = rarfile.RarFile(str(self.path))
-            except (OSError, rarfile.RarFileError) as e:
-                logger.error("Unable to get rar object [%s]: %s", e, self.path)
-            else:
-                return rarc
-
-        return None

comicapi/archivers/sevenzip.py

@@ -1,131 +0,0 @@
-from __future__ import annotations
-
-import logging
-import os
-import pathlib
-import shutil
-import tempfile
-
-from comicapi.archivers import Archiver
-
-try:
-    import py7zr
-
-    z7_support = True
-except ImportError:
-    z7_support = False
-
-logger = logging.getLogger(__name__)
-
-
-class SevenZipArchiver(Archiver):
-    """7Z implementation"""
-
-    enabled = z7_support
-
-    def __init__(self) -> None:
-        super().__init__()
-
-    # @todo: Implement Comment?
-    def get_comment(self) -> str:
-        return ""
-
-    def set_comment(self, comment: str) -> bool:
-        return False
-
-    def read_file(self, archive_file: str) -> bytes:
-        data = b""
-        try:
-            with py7zr.SevenZipFile(self.path, "r") as zf:
-                data = zf.read(archive_file)[archive_file].read()
-        except (py7zr.Bad7zFile, OSError) as e:
-            logger.error("Error reading 7zip archive [%s]: %s :: %s", e, self.path, archive_file)
-            raise
-
-        return data
-
-    def remove_file(self, archive_file: str) -> bool:
-        return self.rebuild([archive_file])
-
-    def write_file(self, archive_file: str, data: bytes) -> bool:
-        # At the moment, no other option but to rebuild the whole
-        # archive w/o the indicated file. Very sucky, but maybe
-        # another solution can be found
-        files = self.get_filename_list()
-        if archive_file in files:
-            if not self.rebuild([archive_file]):
-                return False
-
-        try:
-            # now just add the archive file as a new one
-            with py7zr.SevenZipFile(self.path, "a") as zf:
-                zf.writestr(data, archive_file)
-            return True
-        except (py7zr.Bad7zFile, OSError) as e:
-            logger.error("Error writing 7zip archive [%s]: %s :: %s", e, self.path, archive_file)
-            return False
-
-    def get_filename_list(self) -> list[str]:
-        try:
-            with py7zr.SevenZipFile(self.path, "r") as zf:
-                namelist: list[str] = [file.filename for file in zf.list() if not file.is_directory]
-
-            return namelist
-        except (py7zr.Bad7zFile, OSError) as e:
-            logger.error("Error listing files in 7zip archive [%s]: %s", e, self.path)
-            return []
-
-    def rebuild(self, exclude_list: list[str]) -> bool:
-        """Zip helper func
-
-        This recompresses the zip archive, without the files in the exclude_list
-        """
-
-        try:
-            # py7zr treats all archives as if they used solid compression
-            # so we need to get the filename list first to read all the files at once
-            with py7zr.SevenZipFile(self.path, mode="r") as zin:
-                targets = [f for f in zin.getnames() if f not in exclude_list]
-            with tempfile.NamedTemporaryFile(dir=os.path.dirname(self.path), delete=False) as tmp_file:
-                with py7zr.SevenZipFile(tmp_file.file, mode="w") as zout:
-                    with py7zr.SevenZipFile(self.path, mode="r") as zin:
-                        for filename, buffer in zin.read(targets).items():
-                            zout.writef(buffer, filename)
-
-                self.path.unlink(missing_ok=True)
-                tmp_file.close()  # Required on windows
-
-                shutil.move(tmp_file.name, self.path)
-        except (py7zr.Bad7zFile, OSError) as e:
-            logger.error("Error rebuilding 7zip file [%s]: %s", e, self.path)
-            return False
-        return True
-
-    def copy_from_archive(self, other_archive: Archiver) -> bool:
-        """Replace the current zip with one copied from another archive"""
-        try:
-            with py7zr.SevenZipFile(self.path, "w") as zout:
-                for filename in other_archive.get_filename_list():
-                    data = other_archive.read_file(
-                        filename
-                    )  # This will be very inefficient if other_archive is a 7z file
-                    if data is not None:
-                        zout.writestr(data, filename)
-        except Exception as e:
-            logger.error("Error while copying to 7zip archive [%s]: from %s to %s", e, other_archive.path, self.path)
-            return False
-        else:
-            return True
-
-    def is_writable(self) -> bool:
-        return True
-
-    def extension(self) -> str:
-        return ".cb7"
-
-    def name(self) -> str:
-        return "Seven Zip"
-
-    @classmethod
-    def is_valid(cls, path: pathlib.Path) -> bool:
-        return py7zr.is_7zfile(path)

comicapi/archivers/zip.py

@@ -1,190 +0,0 @@
-from __future__ import annotations
-
-import logging
-import os
-import pathlib
-import shutil
-import struct
-import tempfile
-import zipfile
-from typing import cast
-
-from comicapi.archivers import Archiver
-
-logger = logging.getLogger(__name__)
-
-
-class ZipArchiver(Archiver):
-
-    """ZIP implementation"""
-
-    def __init__(self) -> None:
-        super().__init__()
-
-    def get_comment(self) -> str:
-        with zipfile.ZipFile(self.path, "r") as zf:
-            comment = zf.comment.decode("utf-8")
-        return comment
-
-    def set_comment(self, comment: str) -> bool:
-        with zipfile.ZipFile(self.path, mode="a") as zf:
-            zf.comment = bytes(comment, "utf-8")
-        return True
-
-    def read_file(self, archive_file: str) -> bytes:
-        with zipfile.ZipFile(self.path, mode="r") as zf:
-            try:
-                data = zf.read(archive_file)
-            except (zipfile.BadZipfile, OSError) as e:
-                logger.error("Error reading zip archive [%s]: %s :: %s", e, self.path, archive_file)
-                raise
-        return data
-
-    def remove_file(self, archive_file: str) -> bool:
-        return self.rebuild([archive_file])
-
-    def write_file(self, archive_file: str, data: bytes) -> bool:
-        # At the moment, no other option but to rebuild the whole
-        # zip archive w/o the indicated file. Very sucky, but maybe
-        # another solution can be found
-        files = self.get_filename_list()
-        if archive_file in files:
-            if not self.rebuild([archive_file]):
-                return False
-
-        try:
-            # now just add the archive file as a new one
-            with zipfile.ZipFile(self.path, mode="a", allowZip64=True, compression=zipfile.ZIP_DEFLATED) as zf:
-                zf.writestr(archive_file, data)
-            return True
-        except (zipfile.BadZipfile, OSError) as e:
-            logger.error("Error writing zip archive [%s]: %s :: %s", e, self.path, archive_file)
-            return False
-
-    def get_filename_list(self) -> list[str]:
-        try:
-            with zipfile.ZipFile(self.path, mode="r") as zf:
-                namelist = [file.filename for file in zf.infolist() if not file.is_dir()]
-            return namelist
-        except (zipfile.BadZipfile, OSError) as e:
-            logger.error("Error listing files in zip archive [%s]: %s", e, self.path)
-            return []
-
-    def rebuild(self, exclude_list: list[str]) -> bool:
-        """Zip helper func
-
-        This recompresses the zip archive, without the files in the exclude_list
-        """
-        try:
-            with zipfile.ZipFile(
-                tempfile.NamedTemporaryFile(dir=os.path.dirname(self.path), delete=False), "w", allowZip64=True
-            ) as zout:
-                with zipfile.ZipFile(self.path, mode="r") as zin:
-                    for item in zin.infolist():
-                        buffer = zin.read(item.filename)
-                        if item.filename not in exclude_list:
-                            zout.writestr(item, buffer)
-
-                    # preserve the old comment
-                    zout.comment = zin.comment
-
-                # replace with the new file
-                self.path.unlink(missing_ok=True)
-                zout.close()  # Required on windows
-
-                shutil.move(cast(str, zout.filename), self.path)
-
-        except (zipfile.BadZipfile, OSError) as e:
-            logger.error("Error rebuilding zip file [%s]: %s", e, self.path)
-            return False
-        return True
-
-    def copy_from_archive(self, other_archive: Archiver) -> bool:
-        """Replace the current zip with one copied from another archive"""
-        try:
-            with zipfile.ZipFile(self.path, mode="w", allowZip64=True) as zout:
-                for filename in other_archive.get_filename_list():
-                    data = other_archive.read_file(filename)
-                    if data is not None:
-                        zout.writestr(filename, data)
-
-            # preserve the old comment
-            comment = other_archive.get_comment()
-            if comment is not None:
-                if not self.write_zip_comment(self.path, comment):
-                    return False
-        except Exception as e:
-            logger.error("Error while copying to zip archive [%s]: from %s to %s", e, other_archive.path, self.path)
-            return False
-        else:
-            return True
-
-    def is_writable(self) -> bool:
-        return True
-
-    def extension(self) -> str:
-        return ".cbz"
-
-    def name(self) -> str:
-        return "ZIP"
-
-    @classmethod
-    def is_valid(cls, path: pathlib.Path) -> bool:
-        return zipfile.is_zipfile(path)
-
-    def write_zip_comment(self, filename: pathlib.Path | str, comment: str) -> bool:
-        """
-        This is a custom function for writing a comment to a zip file,
-        since the built-in one doesn't seem to work on Windows and Mac OS/X
-
-        Fortunately, the zip comment is at the end of the file, and it's
-        easy to manipulate.  See this website for more info:
-        see: http://en.wikipedia.org/wiki/Zip_(file_format)#Structure
-        """
-
-        # get file size
-        statinfo = os.stat(filename)
-        file_length = statinfo.st_size
-
-        try:
-            with open(filename, mode="r+b") as file:
-                # the starting position, relative to EOF
-                pos = -4
-                found = False
-
-                # walk backwards to find the "End of Central Directory" record
-                while (not found) and (-pos != file_length):
-                    # seek, relative to EOF
-                    file.seek(pos, 2)
-                    value = file.read(4)
-
-                    # look for the end of central directory signature
-                    if bytearray(value) == bytearray([0x50, 0x4B, 0x05, 0x06]):
-                        found = True
-                    else:
-                        # not found, step back another byte
-                        pos = pos - 1
-
-                if found:
-                    # now skip forward 20 bytes to the comment length word
-                    pos += 20
-                    file.seek(pos, 2)
-
-                    # Pack the length of the comment string
-                    fmt = "H"  # one 2-byte integer
-                    comment_length = struct.pack(fmt, len(comment))  # pack integer in a binary string
-
-                    # write out the length
-                    file.write(comment_length)
-                    file.seek(pos + 2, 2)
-
-                    # write out the comment itself
-                    file.write(comment.encode("utf-8"))
-                    file.truncate()
-                else:
-                    raise Exception("Could not find the End of Central Directory record!")
-        except Exception as e:
-            logger.error("Error writing comment to zip archive [%s]: %s", e, self.path)
-            return False
-        else:
-            return True

comicapi/comet.py

@@ -1,212 +0,0 @@
-"""A class to encapsulate CoMet data"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-from __future__ import annotations
-
-import logging
-import xml.etree.ElementTree as ET
-from typing import Any
-
-from comicapi import utils
-from comicapi.genericmetadata import GenericMetadata
-
-logger = logging.getLogger(__name__)
-
-
-class CoMet:
-    writer_synonyms = ["writer", "plotter", "scripter"]
-    penciller_synonyms = ["artist", "penciller", "penciler", "breakdowns"]
-    inker_synonyms = ["inker", "artist", "finishes"]
-    colorist_synonyms = ["colorist", "colourist", "colorer", "colourer"]
-    letterer_synonyms = ["letterer"]
-    cover_synonyms = ["cover", "covers", "coverartist", "cover artist"]
-    editor_synonyms = ["editor"]
-
-    def metadata_from_string(self, string: str) -> GenericMetadata:
-        tree = ET.ElementTree(ET.fromstring(string))
-        return self.convert_xml_to_metadata(tree)
-
-    def string_from_metadata(self, metadata: GenericMetadata) -> str:
-        tree = self.convert_metadata_to_xml(metadata)
-        return str(ET.tostring(tree.getroot(), encoding="utf-8", xml_declaration=True).decode("utf-8"))
-
-    def convert_metadata_to_xml(self, metadata: GenericMetadata) -> ET.ElementTree:
-        # shorthand for the metadata
-        md = metadata
-
-        # build a tree structure
-        root = ET.Element("comet")
-        root.attrib["xmlns:comet"] = "http://www.denvog.com/comet/"
-        root.attrib["xmlns:xsi"] = "http://www.w3.org/2001/XMLSchema-instance"
-        root.attrib["xsi:schemaLocation"] = "http://www.denvog.com http://www.denvog.com/comet/comet.xsd"
-
-        # helper func
-        def assign(comet_entry: str, md_entry: Any) -> None:
-            if md_entry is not None:
-                ET.SubElement(root, comet_entry).text = str(md_entry)
-
-        # title is manditory
-        if md.title is None:
-            md.title = ""
-        assign("title", md.title)
-        assign("series", md.series)
-        assign("issue", md.issue)  # must be int??
-        assign("volume", md.volume)
-        assign("description", md.comments)
-        assign("publisher", md.publisher)
-        assign("pages", md.page_count)
-        assign("format", md.format)
-        assign("language", md.language)
-        assign("rating", md.maturity_rating)
-        assign("price", md.price)
-        assign("isVersionOf", md.is_version_of)
-        assign("rights", md.rights)
-        assign("identifier", md.identifier)
-        assign("lastMark", md.last_mark)
-        assign("genre", md.genre)  # TODO repeatable
-
-        if md.characters is not None:
-            char_list = [c.strip() for c in md.characters.split(",")]
-            for c in char_list:
-                assign("character", c)
-
-        if md.manga is not None and md.manga == "YesAndRightToLeft":
-            assign("readingDirection", "rtl")
-
-        if md.year is not None:
-            date_str = f"{md.year:04}"
-            if md.month is not None:
-                date_str += f"-{md.month:02}"
-            assign("date", date_str)
-
-        assign("coverImage", md.cover_image)
-
-        # loop thru credits, and build a list for each role that CoMet supports
-        for credit in metadata.credits:
-            if credit["role"].casefold() in set(self.writer_synonyms):
-                ET.SubElement(root, "writer").text = str(credit["person"])
-
-            if credit["role"].casefold() in set(self.penciller_synonyms):
-                ET.SubElement(root, "penciller").text = str(credit["person"])
-
-            if credit["role"].casefold() in set(self.inker_synonyms):
-                ET.SubElement(root, "inker").text = str(credit["person"])
-
-            if credit["role"].casefold() in set(self.colorist_synonyms):
-                ET.SubElement(root, "colorist").text = str(credit["person"])
-
-            if credit["role"].casefold() in set(self.letterer_synonyms):
-                ET.SubElement(root, "letterer").text = str(credit["person"])
-
-            if credit["role"].casefold() in set(self.cover_synonyms):
-                ET.SubElement(root, "coverDesigner").text = str(credit["person"])
-
-            if credit["role"].casefold() in set(self.editor_synonyms):
-                ET.SubElement(root, "editor").text = str(credit["person"])
-
-        ET.indent(root)
-
-        # wrap it in an ElementTree instance, and save as XML
-        tree = ET.ElementTree(root)
-        return tree
-
-    def convert_xml_to_metadata(self, tree: ET.ElementTree) -> GenericMetadata:
-        root = tree.getroot()
-
-        if root.tag != "comet":
-            raise Exception("Not a CoMet file")
-
-        metadata = GenericMetadata()
-        md = metadata
-
-        # Helper function
-        def get(tag: str) -> Any:
-            node = root.find(tag)
-            if node is not None:
-                return node.text
-            return None
-
-        md.series = utils.xlate(get("series"))
-        md.title = utils.xlate(get("title"))
-        md.issue = utils.xlate(get("issue"))
-        md.volume = utils.xlate(get("volume"), True)
-        md.comments = utils.xlate(get("description"))
-        md.publisher = utils.xlate(get("publisher"))
-        md.language = utils.xlate(get("language"))
-        md.format = utils.xlate(get("format"))
-        md.page_count = utils.xlate(get("pages"), True)
-        md.maturity_rating = utils.xlate(get("rating"))
-        md.price = utils.xlate(get("price"), is_float=True)
-        md.is_version_of = utils.xlate(get("isVersionOf"))
-        md.rights = utils.xlate(get("rights"))
-        md.identifier = utils.xlate(get("identifier"))
-        md.last_mark = utils.xlate(get("lastMark"))
-        md.genre = utils.xlate(get("genre"))  # TODO - repeatable field
-
-        _, md.month, md.year = utils.parse_date_str(utils.xlate(get("date")))
-
-        md.cover_image = utils.xlate(get("coverImage"))
-
-        reading_direction = utils.xlate(get("readingDirection"))
-        if reading_direction is not None and reading_direction == "rtl":
-            md.manga = "YesAndRightToLeft"
-
-        # loop for character tags
-        char_list = []
-        for n in root:
-            if n.tag == "character":
-                char_list.append((n.text or "").strip())
-        md.characters = ", ".join(char_list)
-
-        # Now extract the credit info
-        for n in root:
-            if any(
-                [
-                    n.tag == "writer",
-                    n.tag == "penciller",
-                    n.tag == "inker",
-                    n.tag == "colorist",
-                    n.tag == "letterer",
-                    n.tag == "editor",
-                ]
-            ):
-                metadata.add_credit((n.text or "").strip(), n.tag.title())
-
-            if n.tag == "coverDesigner":
-                metadata.add_credit((n.text or "").strip(), "Cover")
-
-        metadata.is_empty = False
-
-        return metadata
-
-    # verify that the string actually contains CoMet data in XML format
-    def validate_string(self, string: str) -> bool:
-        try:
-            tree = ET.ElementTree(ET.fromstring(string))
-            root = tree.getroot()
-            if root.tag != "comet":
-                return False
-        except ET.ParseError:
-            return False
-
-        return True
-
-    def write_to_external_file(self, filename: str, metadata: GenericMetadata) -> None:
-        tree = self.convert_metadata_to_xml(metadata)
-        tree.write(filename, encoding="utf-8")
-
-    def read_from_external_file(self, filename: str) -> GenericMetadata:
-        tree = ET.parse(filename)
-        return self.convert_xml_to_metadata(tree)

comicapi/comicarchive.py

@@ -1,603 +0,0 @@
-"""A class to represent a single comic, be it file or folder of images"""
-# Copyright 2012-2014 ComicTagger Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-from __future__ import annotations
-
-import io
-import logging
-import os
-import pathlib
-import shutil
-import sys
-from typing import cast
-
-import wordninja
-
-from comicapi import filenamelexer, filenameparser, utils
-from comicapi.archivers import Archiver, UnknownArchiver, ZipArchiver
-from comicapi.comet import CoMet
-from comicapi.comicbookinfo import ComicBookInfo
-from comicapi.comicinfoxml import ComicInfoXml
-from comicapi.genericmetadata import GenericMetadata, PageType
-
-if sys.version_info < (3, 10):
-    from importlib_metadata import entry_points
-else:
-    from importlib.metadata import entry_points
-
-try:
-    from PIL import Image
-
-    pil_available = True
-except ImportError:
-    pil_available = False
-
-logger = logging.getLogger(__name__)
-
-if not pil_available:
-    logger.error("PIL unavalable")
-
-archivers: list[type[Archiver]] = []
-
-
-def load_archive_plugins() -> None:
-    if not archivers:
-        builtin: list[type[Archiver]] = []
-        for arch in entry_points(group="comicapi.archiver"):
-            try:
-                archiver: type[Archiver] = arch.load()
-                if archiver.enabled:
-                    if arch.module.startswith("comicapi"):
-                        builtin.append(archiver)
-                    else:
-                        archivers.append(archiver)
-            except Exception:
-                logger.warning("Failed to load talker: %s", arch.name)
-        archivers.extend(builtin)
-
-
-class MetaDataStyle:
-    CBI = 0
-    CIX = 1
-    COMET = 2
-    name = ["ComicBookLover", "ComicRack", "CoMet"]
-    short_name = ["cbl", "cr", "comet"]
-
-
-class ComicArchive:
-    logo_data = b""
-
-    def __init__(self, path: pathlib.Path | str, default_image_path: pathlib.Path | str | None = None) -> None:
-        self.cbi_md: GenericMetadata | None = None
-        self.cix_md: GenericMetadata | None = None
-        self.comet_filename: str | None = None
-        self.comet_md: GenericMetadata | None = None
-        self._has_cbi: bool | None = None
-        self._has_cix: bool | None = None
-        self._has_comet: bool | None = None
-        self.path = pathlib.Path(path).absolute()
-        self.page_count: int | None = None
-        self.page_list: list[str] = []
-
-        self.ci_xml_filename = "ComicInfo.xml"
-        self.comet_default_filename = "CoMet.xml"
-        self.reset_cache()
-        self.default_image_path = default_image_path
-
-        self.archiver: Archiver = UnknownArchiver.open(self.path)
-
-        load_archive_plugins()
-        for archiver in archivers:
-            if archiver.is_valid(self.path):
-                self.archiver = archiver.open(self.path)
-                break
-
-        if not ComicArchive.logo_data and self.default_image_path:
-            with open(self.default_image_path, mode="rb") as fd:
-                ComicArchive.logo_data = fd.read()
-
-    def reset_cache(self) -> None:
-        """Clears the cached data"""
-
-        self._has_cix = None
-        self._has_cbi = None
-        self._has_comet = None
-        self.comet_filename = None
-        self.page_count = None
-        self.page_list = []
-        self.cix_md = None
-        self.cbi_md = None
-        self.comet_md = None
-
-    def load_cache(self, style_list: list[int]) -> None:
-        for style in style_list:
-            self.read_metadata(style)
-
-    def rename(self, path: pathlib.Path | str) -> None:
-        new_path = pathlib.Path(path).absolute()
-        if new_path == self.path:
-            return
-        os.makedirs(new_path.parent, 0o777, True)
-        shutil.move(self.path, new_path)
-        self.path = new_path
-        self.archiver.path = pathlib.Path(path)
-
-    def is_writable(self, check_archive_status: bool = True) -> bool:
-        if isinstance(self.archiver, UnknownArchiver):
-            return False
-
-        if check_archive_status and not self.archiver.is_writable():
-            return False
-
-        if not (os.access(self.path, os.W_OK) or os.access(self.path.parent, os.W_OK)):
-            return False
-
-        return True
-
-    def is_writable_for_style(self, data_style: int) -> bool:
-        return not (data_style == MetaDataStyle.CBI and not self.archiver.supports_comment)
-
-    def is_zip(self) -> bool:
-        return self.archiver.name() == "ZIP"
-
-    def seems_to_be_a_comic_archive(self) -> bool:
-        if not (isinstance(self.archiver, UnknownArchiver)) and self.get_number_of_pages() > 0:
-            return True
-
-        return False
-
-    def extension(self) -> str:
-        return self.archiver.extension()
-
-    def read_metadata(self, style: int) -> GenericMetadata:
-        if style == MetaDataStyle.CIX:
-            return self.read_cix()
-        if style == MetaDataStyle.CBI:
-            return self.read_cbi()
-        if style == MetaDataStyle.COMET:
-            return self.read_comet()
-        return GenericMetadata()
-
-    def write_metadata(self, metadata: GenericMetadata, style: int) -> bool:
-        retcode = False
-        if style == MetaDataStyle.CIX:
-            retcode = self.write_cix(metadata)
-        if style == MetaDataStyle.CBI:
-            retcode = self.write_cbi(metadata)
-        if style == MetaDataStyle.COMET:
-            retcode = self.write_comet(metadata)
-        return retcode
-
-    def has_metadata(self, style: int) -> bool:
-        if style == MetaDataStyle.CIX:
-            return self.has_cix()
-        if style == MetaDataStyle.CBI:
-            return self.has_cbi()
-        if style == MetaDataStyle.COMET:
-            return self.has_comet()
-        return False
-
-    def remove_metadata(self, style: int) -> bool:
-        retcode = True
-        if style == MetaDataStyle.CIX:
-            retcode = self.remove_cix()
-        elif style == MetaDataStyle.CBI:
-            retcode = self.remove_cbi()
-        elif style == MetaDataStyle.COMET:
-            retcode = self.remove_co_met()
-        return retcode
-
-    def get_page(self, index: int) -> bytes:
-        image_data = b""
-
-        filename = self.get_page_name(index)
-
-        if filename:
-            try:
-                image_data = self.archiver.read_file(filename) or b""
-            except Exception:
-                logger.error("Error reading in page %d. Substituting logo page.", index)
-                image_data = ComicArchive.logo_data
-
-        return image_data
-
-    def get_page_name(self, index: int) -> str:
-        if index is None:
-            return ""
-
-        page_list = self.get_page_name_list()
-
-        num_pages = len(page_list)
-        if num_pages == 0 or index >= num_pages:
-            return ""
-
-        return page_list[index]
-
-    def get_scanner_page_index(self) -> int | None:
-        scanner_page_index = None
-
-        # make a guess at the scanner page
-        name_list = self.get_page_name_list()
-        count = self.get_number_of_pages()
-
-        # too few pages to really know
-        if count < 5:
-            return None
-
-        # count the length of every filename, and count occurrences
-        length_buckets: dict[int, int] = {}
-        for name in name_list:
-            fname = os.path.split(name)[1]
-            length = len(fname)
-            if length in length_buckets:
-                length_buckets[length] += 1
-            else:
-                length_buckets[length] = 1
-
-        # sort by most common
-        sorted_buckets = sorted(length_buckets.items(), key=lambda tup: (tup[1], tup[0]), reverse=True)
-
-        # statistical mode occurrence is first
-        mode_length = sorted_buckets[0][0]
-
-        # we are only going to consider the final image file:
-        final_name = os.path.split(name_list[count - 1])[1]
-
-        common_length_list = []
-        for name in name_list:
-            if len(os.path.split(name)[1]) == mode_length:
-                common_length_list.append(os.path.split(name)[1])
-
-        prefix = os.path.commonprefix(common_length_list)
-
-        if mode_length <= 7 and prefix == "":
-            # probably all numbers
-            if len(final_name) > mode_length:
-                scanner_page_index = count - 1
-
-        # see if the last page doesn't start with the same prefix as most others
-        elif not final_name.startswith(prefix):
-            scanner_page_index = count - 1
-
-        return scanner_page_index
-
-    def get_page_name_list(self, sort_list: bool = True) -> list[str]:
-        if not self.page_list:
-            # get the list file names in the archive, and sort
-            files: list[str] = self.archiver.get_filename_list()
-
-            # seems like some archive creators are on Windows, and don't know about case-sensitivity!
-            if sort_list:
-                files = cast(list[str], utils.os_sorted(files))
-
-            # make a sub-list of image files
-            self.page_list = []
-            for name in files:
-                if (
-                    os.path.splitext(name)[1].casefold() in [".jpg", ".jpeg", ".png", ".gif", ".webp"]
-                    and os.path.basename(name)[0] != "."
-                ):
-                    self.page_list.append(name)
-
-        return self.page_list
-
-    def get_number_of_pages(self) -> int:
-        if self.page_count is None:
-            self.page_count = len(self.get_page_name_list())
-        return self.page_count
-
-    def read_cbi(self) -> GenericMetadata:
-        if self.cbi_md is None:
-            raw_cbi = self.read_raw_cbi()
-            if raw_cbi:
-                self.cbi_md = ComicBookInfo().metadata_from_string(raw_cbi)
-            else:
-                self.cbi_md = GenericMetadata()
-
-            self.cbi_md.set_default_page_list(self.get_number_of_pages())
-
-        return self.cbi_md
-
-    def read_raw_cbi(self) -> str:
-        if not self.has_cbi():
-            return ""
-
-        return self.archiver.get_comment()
-
-    def has_cbi(self) -> bool:
-        if self._has_cbi is None:
-            if not self.seems_to_be_a_comic_archive():
-                self._has_cbi = False
-            else:
-                comment = self.archiver.get_comment()
-                self._has_cbi = ComicBookInfo().validate_string(comment)
-
-        return self._has_cbi
-
-    def write_cbi(self, metadata: GenericMetadata) -> bool:
-        if metadata is not None:
-            try:
-                self.apply_archive_info_to_metadata(metadata)
-                cbi_string = ComicBookInfo().string_from_metadata(metadata)
-                write_success = self.archiver.set_comment(cbi_string)
-                if write_success:
-                    self._has_cbi = True
-                    self.cbi_md = metadata
-                self.reset_cache()
-                return write_success
-            except Exception as e:
-                logger.error("Error saving CBI! for %s: %s", self.path, e)
-
-        return False
-
-    def remove_cbi(self) -> bool:
-        if self.has_cbi():
-            write_success = self.archiver.set_comment("")
-            if write_success:
-                self._has_cbi = False
-                self.cbi_md = None
-            self.reset_cache()
-            return write_success
-        return True
-
-    def read_cix(self) -> GenericMetadata:
-        if self.cix_md is None:
-            raw_cix = self.read_raw_cix()
-            if raw_cix:
-                self.cix_md = ComicInfoXml().metadata_from_string(raw_cix)
-            else:
-                self.cix_md = GenericMetadata()
-
-            # validate the existing page list (make sure count is correct)
-            if len(self.cix_md.pages) != 0:
-                if len(self.cix_md.pages) != self.get_number_of_pages():
-                    # pages array doesn't match the actual number of images we're seeing
-                    # in the archive, so discard the data
-                    self.cix_md.pages = []
-
-            if len(self.cix_md.pages) == 0:
-                self.cix_md.set_default_page_list(self.get_number_of_pages())
-
-        return self.cix_md
-
-    def read_raw_cix(self) -> bytes:
-        if not self.has_cix():
-            return b""
-        try:
-            raw_cix = self.archiver.read_file(self.ci_xml_filename) or b""
-        except Exception as e:
-            logger.error("Error reading in raw CIX! for %s: %s", self.path, e)
-            raw_cix = b""
-        return raw_cix
-
-    def write_cix(self, metadata: GenericMetadata) -> bool:
-        if metadata is not None:
-            try:
-                self.apply_archive_info_to_metadata(metadata, calc_page_sizes=True)
-                raw_cix = self.read_raw_cix()
-                cix_string = ComicInfoXml().string_from_metadata(metadata, xml=raw_cix)
-                write_success = self.archiver.write_file(self.ci_xml_filename, cix_string.encode("utf-8"))
-                if write_success:
-                    self._has_cix = True
-                    self.cix_md = metadata
-                self.reset_cache()
-                return write_success
-            except Exception as e:
-                logger.error("Error saving CIX! for %s: %s", self.path, e)
-
-        return False
-
-    def remove_cix(self) -> bool:
-        if self.has_cix():
-            write_success = self.archiver.remove_file(self.ci_xml_filename)
-            if write_success:
-                self._has_cix = False
-                self.cix_md = None
-            self.reset_cache()
-            return write_success
-        return True
-
-    def has_cix(self) -> bool:
-        if self._has_cix is None:
-            if not self.seems_to_be_a_comic_archive():
-                self._has_cix = False
-            elif self.ci_xml_filename in self.archiver.get_filename_list():
-                self._has_cix = True
-            else:
-                self._has_cix = False
-        return self._has_cix
-
-    def read_comet(self) -> GenericMetadata:
-        if self.comet_md is None:
-            raw_comet = self.read_raw_comet()
-            if raw_comet is None or raw_comet == "":
-                self.comet_md = GenericMetadata()
-            else:
-                self.comet_md = CoMet().metadata_from_string(raw_comet)
-
-            self.comet_md.set_default_page_list(self.get_number_of_pages())
-            # use the coverImage value from the comet_data to mark the cover in this struct
-            # walk through list of images in file, and find the matching one for md.coverImage
-            # need to remove the existing one in the default
-            if self.comet_md.cover_image is not None:
-                cover_idx = 0
-                for idx, f in enumerate(self.get_page_name_list()):
-                    if self.comet_md.cover_image == f:
-                        cover_idx = idx
-                        break
-                if cover_idx != 0:
-                    del self.comet_md.pages[0]["Type"]
-                    self.comet_md.pages[cover_idx]["Type"] = PageType.FrontCover
-
-        return self.comet_md
-
-    def read_raw_comet(self) -> str:
-        raw_comet = ""
-        if not self.has_comet():
-            raw_comet = ""
-        else:
-            try:
-                raw_bytes = self.archiver.read_file(cast(str, self.comet_filename))
-                if raw_bytes:
-                    raw_comet = raw_bytes.decode("utf-8")
-            except OSError as e:
-                logger.exception("Error reading in raw CoMet!: %s", e)
-        return raw_comet
-
-    def write_comet(self, metadata: GenericMetadata) -> bool:
-        if metadata is not None:
-            if not self.has_comet():
-                self.comet_filename = self.comet_default_filename
-
-            self.apply_archive_info_to_metadata(metadata)
-            # Set the coverImage value, if it's not the first page
-            cover_idx = int(metadata.get_cover_page_index_list()[0])
-            if cover_idx != 0:
-                metadata.cover_image = self.get_page_name(cover_idx)
-
-            comet_string = CoMet().string_from_metadata(metadata)
-            write_success = self.archiver.write_file(cast(str, self.comet_filename), comet_string.encode("utf-8"))
-            if write_success:
-                self._has_comet = True
-                self.comet_md = metadata
-            self.reset_cache()
-            return write_success
-
-        return False
-
-    def remove_co_met(self) -> bool:
-        if self.has_comet():
-            write_success = self.archiver.remove_file(cast(str, self.comet_filename))
-            if write_success:
-                self._has_comet = False
-                self.comet_md = None
-            self.reset_cache()
-            return write_success
-        return True
-
-    def has_comet(self) -> bool:
-        if self._has_comet is None:
-            self._has_comet = False
-            if not self.seems_to_be_a_comic_archive():
-                return self._has_comet
-
-            # look at all xml files in root, and search for CoMet data, get first
-            for n in self.archiver.get_filename_list():
-                if os.path.dirname(n) == "" and os.path.splitext(n)[1].casefold() == ".xml":
-                    # read in XML file, and validate it
-                    data = ""
-                    try:
-                        d = self.archiver.read_file(n)
-                        if d:
-                            data = d.decode("utf-8")
-                    except Exception as e:
-                        logger.warning("Error reading in Comet XML for validation! from %s: %s", self.path, e)
-                    if CoMet().validate_string(data):
-                        # since we found it, save it!
-                        self.comet_filename = n
-                        self._has_comet = True
-                        break
-
-        return self._has_comet
-
-    def apply_archive_info_to_metadata(self, md: GenericMetadata, calc_page_sizes: bool = False) -> None:
-        md.page_count = self.get_number_of_pages()
-
-        if calc_page_sizes:
-            for index, p in enumerate(md.pages):
-                idx = int(p["Image"])
-                if pil_available:
-                    if "ImageSize" not in p or "ImageHeight" not in p or "ImageWidth" not in p:
-                        data = self.get_page(idx)
-                        if data:
-                            try:
-                                if isinstance(data, bytes):
-                                    im = Image.open(io.BytesIO(data))
-                                else:
-                                    im = Image.open(io.StringIO(data))
-                                w, h = im.size
-
-                                p["ImageSize"] = str(len(data))
-                                p["ImageHeight"] = str(h)
-                                p["ImageWidth"] = str(w)
-                            except Exception as e:
-                                logger.warning("Error decoding image [%s] %s :: image %s", e, self.path, index)
-                                p["ImageSize"] = str(len(data))
-
-                else:
-                    if "ImageSize" not in p:
-                        data = self.get_page(idx)
-                        p["ImageSize"] = str(len(data))
-
-    def metadata_from_filename(
-        self,
-        complicated_parser: bool = False,
-        remove_c2c: bool = False,
-        remove_fcbd: bool = False,
-        remove_publisher: bool = False,
-        split_words: bool = False,
-    ) -> GenericMetadata:
-        metadata = GenericMetadata()
-
-        filename = self.path.name
-        if split_words:
-            filename = " ".join(wordninja.split(self.path.stem)) + self.path.suffix
-
-        if complicated_parser:
-            lex = filenamelexer.Lex(filename)
-            p = filenameparser.Parse(
-                lex.items, remove_c2c=remove_c2c, remove_fcbd=remove_fcbd, remove_publisher=remove_publisher
-            )
-            metadata.alternate_number = utils.xlate(p.filename_info["alternate"])
-            metadata.issue = utils.xlate(p.filename_info["issue"])
-            metadata.issue_count = utils.xlate(p.filename_info["issue_count"])
-            metadata.publisher = utils.xlate(p.filename_info["publisher"])
-            metadata.series = utils.xlate(p.filename_info["series"])
-            metadata.title = utils.xlate(p.filename_info["title"])
-            metadata.volume = utils.xlate(p.filename_info["volume"])
-            metadata.volume_count = utils.xlate(p.filename_info["volume_count"])
-            metadata.year = utils.xlate(p.filename_info["year"])
-
-            metadata.scan_info = utils.xlate(p.filename_info["remainder"])
-            metadata.format = "FCBD" if p.filename_info["fcbd"] else None
-            if p.filename_info["annual"]:
-                metadata.format = "Annual"
-        else:
-            fnp = filenameparser.FileNameParser()
-            fnp.parse_filename(filename)
-
-            if fnp.issue:
-                metadata.issue = fnp.issue
-            if fnp.series:
-                metadata.series = fnp.series
-            if fnp.volume:
-                metadata.volume = utils.xlate(fnp.volume, True)
-            if fnp.year:
-                metadata.year = utils.xlate(fnp.year, True)
-            if fnp.issue_count:
-                metadata.issue_count = utils.xlate(fnp.issue_count, True)
-            if fnp.remainder:
-                metadata.scan_info = fnp.remainder
-
-        metadata.is_empty = False
-
-        return metadata
-
-    def export_as_zip(self, zip_filename: pathlib.Path) -> bool:
-        if self.archiver.name() == "ZIP":
-            # nothing to do, we're already a zip
-            return True
-
-        zip_archiver = ZipArchiver.open(zip_filename)
-        return zip_archiver.copy_from_archive(self.archiver)

comicapi/comicbookinfo.py

@@ -1,174 +0,0 @@
-"""A class to encapsulate the ComicBookInfo data"""
-# Copyright 2012-2014 ComicTagger Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-from __future__ import annotations
-
-import json
-import logging
-from collections import defaultdict
-from datetime import datetime
-from typing import Any, Literal, TypedDict
-
-from comicapi import utils
-from comicapi.genericmetadata import GenericMetadata
-
-logger = logging.getLogger(__name__)
-
-CBILiteralType = Literal[
-    "series",
-    "title",
-    "issue",
-    "publisher",
-    "publicationMonth",
-    "publicationYear",
-    "numberOfIssues",
-    "comments",
-    "genre",
-    "volume",
-    "numberOfVolumes",
-    "language",
-    "country",
-    "rating",
-    "credits",
-    "tags",
-]
-
-
-class Credits(TypedDict):
-    person: str
-    role: str
-    primary: bool
-
-
-class ComicBookInfoJson(TypedDict, total=False):
-    series: str
-    title: str
-    publisher: str
-    publicationMonth: int
-    publicationYear: int
-    issue: int
-    numberOfIssues: int
-    volume: int
-    numberOfVolumes: int
-    rating: int
-    genre: str
-    language: str
-    country: str
-    credits: list[Credits]
-    tags: list[str]
-    comments: str
-
-
-CBIContainer = TypedDict("CBIContainer", {"appID": str, "lastModified": str, "ComicBookInfo/1.0": ComicBookInfoJson})
-
-
-class ComicBookInfo:
-    def metadata_from_string(self, string: str) -> GenericMetadata:
-        cbi_container = json.loads(string)
-
-        metadata = GenericMetadata()
-
-        cbi = defaultdict(lambda: None, cbi_container["ComicBookInfo/1.0"])
-
-        metadata.series = utils.xlate(cbi["series"])
-        metadata.title = utils.xlate(cbi["title"])
-        metadata.issue = utils.xlate(cbi["issue"])
-        metadata.publisher = utils.xlate(cbi["publisher"])
-        metadata.month = utils.xlate(cbi["publicationMonth"], True)
-        metadata.year = utils.xlate(cbi["publicationYear"], True)
-        metadata.issue_count = utils.xlate(cbi["numberOfIssues"], True)
-        metadata.comments = utils.xlate(cbi["comments"])
-        metadata.genre = utils.xlate(cbi["genre"])
-        metadata.volume = utils.xlate(cbi["volume"], True)
-        metadata.volume_count = utils.xlate(cbi["numberOfVolumes"], True)
-        metadata.language = utils.xlate(cbi["language"])
-        metadata.country = utils.xlate(cbi["country"])
-        metadata.critical_rating = utils.xlate(cbi["rating"], True)
-
-        metadata.credits = [
-            Credits(
-                person=x["person"] if "person" in x else "",
-                role=x["role"] if "role" in x else "",
-                primary=x["primary"] if "primary" in x else False,
-            )
-            for x in cbi["credits"]
-        ]
-        metadata.tags = set(cbi["tags"]) if cbi["tags"] is not None else set()
-
-        # make sure credits and tags are at least empty lists and not None
-        if metadata.credits is None:
-            metadata.credits = []
-
-        # need the language string to be ISO
-        if metadata.language:
-            metadata.language = utils.get_language_iso(metadata.language)
-
-        metadata.is_empty = False
-
-        return metadata
-
-    def string_from_metadata(self, metadata: GenericMetadata) -> str:
-        cbi_container = self.create_json_dictionary(metadata)
-        return json.dumps(cbi_container)
-
-    def validate_string(self, string: bytes | str) -> bool:
-        """Verify that the string actually contains CBI data in JSON format"""
-
-        try:
-            cbi_container = json.loads(string)
-        except json.JSONDecodeError:
-            return False
-
-        return "ComicBookInfo/1.0" in cbi_container
-
-    def create_json_dictionary(self, metadata: GenericMetadata) -> CBIContainer:
-        """Create the dictionary that we will convert to JSON text"""
-
-        cbi_container = CBIContainer(
-            {
-                "appID": "ComicTagger/1.0.0",
-                "lastModified": str(datetime.now()),
-                "ComicBookInfo/1.0": {},
-            }
-        )  # TODO: ctversion.version,
-
-        # helper func
-        def assign(cbi_entry: CBILiteralType, md_entry: Any) -> None:
-            if md_entry is not None or isinstance(md_entry, str) and md_entry != "":
-                cbi_container["ComicBookInfo/1.0"][cbi_entry] = md_entry
-
-        assign("series", utils.xlate(metadata.series))
-        assign("title", utils.xlate(metadata.title))
-        assign("issue", utils.xlate(metadata.issue))
-        assign("publisher", utils.xlate(metadata.publisher))
-        assign("publicationMonth", utils.xlate(metadata.month, True))
-        assign("publicationYear", utils.xlate(metadata.year, True))
-        assign("numberOfIssues", utils.xlate(metadata.issue_count, True))
-        assign("comments", utils.xlate(metadata.comments))
-        assign("genre", utils.xlate(metadata.genre))
-        assign("volume", utils.xlate(metadata.volume, True))
-        assign("numberOfVolumes", utils.xlate(metadata.volume_count, True))
-        assign("language", utils.xlate(utils.get_language_from_iso(metadata.language)))
-        assign("country", utils.xlate(metadata.country))
-        assign("rating", utils.xlate(metadata.critical_rating, True))
-        assign("credits", metadata.credits)
-        assign("tags", list(metadata.tags))
-
-        return cbi_container
-
-    def write_to_external_file(self, filename: str, metadata: GenericMetadata) -> None:
-        cbi_container = self.create_json_dictionary(metadata)
-
-        with open(filename, "w", encoding="utf-8") as f:
-            f.write(json.dumps(cbi_container, indent=4))

comicapi/comicinfoxml.py

@@ -1,265 +0,0 @@
-"""A class to encapsulate ComicRack's ComicInfo.xml data"""
-# Copyright 2012-2014 ComicTagger Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-from __future__ import annotations
-
-import logging
-import xml.etree.ElementTree as ET
-from collections import OrderedDict
-from typing import Any, cast
-from xml.etree.ElementTree import ElementTree
-
-from comicapi import utils
-from comicapi.genericmetadata import GenericMetadata, ImageMetadata
-from comicapi.issuestring import IssueString
-
-logger = logging.getLogger(__name__)
-
-
-class ComicInfoXml:
-    writer_synonyms = ["writer", "plotter", "scripter"]
-    penciller_synonyms = ["artist", "penciller", "penciler", "breakdowns"]
-    inker_synonyms = ["inker", "artist", "finishes"]
-    colorist_synonyms = ["colorist", "colourist", "colorer", "colourer"]
-    letterer_synonyms = ["letterer"]
-    cover_synonyms = ["cover", "covers", "coverartist", "cover artist"]
-    editor_synonyms = ["editor"]
-
-    def get_parseable_credits(self) -> list[str]:
-        parsable_credits = []
-        parsable_credits.extend(self.writer_synonyms)
-        parsable_credits.extend(self.penciller_synonyms)
-        parsable_credits.extend(self.inker_synonyms)
-        parsable_credits.extend(self.colorist_synonyms)
-        parsable_credits.extend(self.letterer_synonyms)
-        parsable_credits.extend(self.cover_synonyms)
-        parsable_credits.extend(self.editor_synonyms)
-        return parsable_credits
-
-    def metadata_from_string(self, string: bytes) -> GenericMetadata:
-        tree = ET.ElementTree(ET.fromstring(string))
-        return self.convert_xml_to_metadata(tree)
-
-    def string_from_metadata(self, metadata: GenericMetadata, xml: bytes = b"") -> str:
-        tree = self.convert_metadata_to_xml(metadata, xml)
-        tree_str = ET.tostring(tree.getroot(), encoding="utf-8", xml_declaration=True).decode("utf-8")
-        return str(tree_str)
-
-    def convert_metadata_to_xml(self, metadata: GenericMetadata, xml: bytes = b"") -> ElementTree:
-        # shorthand for the metadata
-        md = metadata
-
-        if xml:
-            root = ET.ElementTree(ET.fromstring(xml)).getroot()
-        else:
-            # build a tree structure
-            root = ET.Element("ComicInfo")
-            root.attrib["xmlns:xsi"] = "http://www.w3.org/2001/XMLSchema-instance"
-            root.attrib["xmlns:xsd"] = "http://www.w3.org/2001/XMLSchema"
-        # helper func
-
-        def assign(cix_entry: str, md_entry: Any) -> None:
-            if md_entry is not None and md_entry:
-                et_entry = root.find(cix_entry)
-                if et_entry is not None:
-                    et_entry.text = str(md_entry)
-                else:
-                    ET.SubElement(root, cix_entry).text = str(md_entry)
-            else:
-                et_entry = root.find(cix_entry)
-                if et_entry is not None:
-                    root.remove(et_entry)
-
-        assign("Title", md.title)
-        assign("Series", md.series)
-        assign("Number", md.issue)
-        assign("Count", md.issue_count)
-        assign("Volume", md.volume)
-        assign("AlternateSeries", md.alternate_series)
-        assign("AlternateNumber", md.alternate_number)
-        assign("StoryArc", md.story_arc)
-        assign("SeriesGroup", md.series_group)
-        assign("AlternateCount", md.alternate_count)
-        assign("Summary", md.comments)
-        assign("Notes", md.notes)
-        assign("Year", md.year)
-        assign("Month", md.month)
-        assign("Day", md.day)
-
-        # need to specially process the credits, since they are structured
-        # differently than CIX
-        credit_writer_list = []
-        credit_penciller_list = []
-        credit_inker_list = []
-        credit_colorist_list = []
-        credit_letterer_list = []
-        credit_cover_list = []
-        credit_editor_list = []
-
-        # first, loop thru credits, and build a list for each role that CIX
-        # supports
-        for credit in metadata.credits:
-            if credit["role"].casefold() in set(self.writer_synonyms):
-                credit_writer_list.append(credit["person"].replace(",", ""))
-
-            if credit["role"].casefold() in set(self.penciller_synonyms):
-                credit_penciller_list.append(credit["person"].replace(",", ""))
-
-            if credit["role"].casefold() in set(self.inker_synonyms):
-                credit_inker_list.append(credit["person"].replace(",", ""))
-
-            if credit["role"].casefold() in set(self.colorist_synonyms):
-                credit_colorist_list.append(credit["person"].replace(",", ""))
-
-            if credit["role"].casefold() in set(self.letterer_synonyms):
-                credit_letterer_list.append(credit["person"].replace(",", ""))
-
-            if credit["role"].casefold() in set(self.cover_synonyms):
-                credit_cover_list.append(credit["person"].replace(",", ""))
-
-            if credit["role"].casefold() in set(self.editor_synonyms):
-                credit_editor_list.append(credit["person"].replace(",", ""))
-
-        # second, convert each list to string, and add to XML struct
-        assign("Writer", ", ".join(credit_writer_list))
-        assign("Penciller", ", ".join(credit_penciller_list))
-        assign("Inker", ", ".join(credit_inker_list))
-        assign("Colorist", ", ".join(credit_colorist_list))
-        assign("Letterer", ", ".join(credit_letterer_list))
-        assign("CoverArtist", ", ".join(credit_cover_list))
-        assign("Editor", ", ".join(credit_editor_list))
-
-        assign("Publisher", md.publisher)
-        assign("Imprint", md.imprint)
-        assign("Genre", md.genre)
-        assign("Web", md.web_link)
-        assign("PageCount", md.page_count)
-        assign("LanguageISO", md.language)
-        assign("Format", md.format)
-        assign("AgeRating", md.maturity_rating)
-        assign("CommunityRating", md.critical_rating)
-        assign("BlackAndWhite", "Yes" if md.black_and_white else None)
-        assign("Manga", md.manga)
-        assign("Characters", md.characters)
-        assign("Teams", md.teams)
-        assign("Locations", md.locations)
-        assign("ScanInformation", md.scan_info)
-
-        #  loop and add the page entries under pages node
-        pages_node = root.find("Pages")
-        if pages_node is not None:
-            pages_node.clear()
-        else:
-            pages_node = ET.SubElement(root, "Pages")
-
-        for page_dict in md.pages:
-            page_node = ET.SubElement(pages_node, "Page")
-            page_node.attrib = OrderedDict(sorted((k, str(v)) for k, v in page_dict.items()))
-
-        ET.indent(root)
-
-        # wrap it in an ElementTree instance, and save as XML
-        tree = ET.ElementTree(root)
-        return tree
-
-    def convert_xml_to_metadata(self, tree: ElementTree) -> GenericMetadata:
-        root = tree.getroot()
-
-        if root.tag != "ComicInfo":
-            raise Exception("Not a ComicInfo file")
-
-        def get(name: str) -> str | None:
-            tag = root.find(name)
-            if tag is None:
-                return None
-            return tag.text
-
-        md = GenericMetadata()
-
-        md.series = utils.xlate(get("Series"))
-        md.title = utils.xlate(get("Title"))
-        md.issue = IssueString(utils.xlate(get("Number"))).as_string()
-        md.issue_count = utils.xlate(get("Count"), True)
-        md.volume = utils.xlate(get("Volume"), True)
-        md.alternate_series = utils.xlate(get("AlternateSeries"))
-        md.alternate_number = IssueString(utils.xlate(get("AlternateNumber"))).as_string()
-        md.alternate_count = utils.xlate(get("AlternateCount"), True)
-        md.comments = utils.xlate(get("Summary"))
-        md.notes = utils.xlate(get("Notes"))
-        md.year = utils.xlate(get("Year"), True)
-        md.month = utils.xlate(get("Month"), True)
-        md.day = utils.xlate(get("Day"), True)
-        md.publisher = utils.xlate(get("Publisher"))
-        md.imprint = utils.xlate(get("Imprint"))
-        md.genre = utils.xlate(get("Genre"))
-        md.web_link = utils.xlate(get("Web"))
-        md.language = utils.xlate(get("LanguageISO"))
-        md.format = utils.xlate(get("Format"))
-        md.manga = utils.xlate(get("Manga"))
-        md.characters = utils.xlate(get("Characters"))
-        md.teams = utils.xlate(get("Teams"))
-        md.locations = utils.xlate(get("Locations"))
-        md.page_count = utils.xlate(get("PageCount"), True)
-        md.scan_info = utils.xlate(get("ScanInformation"))
-        md.story_arc = utils.xlate(get("StoryArc"))
-        md.series_group = utils.xlate(get("SeriesGroup"))
-        md.maturity_rating = utils.xlate(get("AgeRating"))
-        md.critical_rating = utils.xlate(get("CommunityRating"), is_float=True)
-
-        tmp = utils.xlate(get("BlackAndWhite"))
-        if tmp is not None and tmp.casefold() in ["yes", "true", "1"]:
-            md.black_and_white = True
-        # Now extract the credit info
-        for n in root:
-            if any(
-                [
-                    n.tag == "Writer",
-                    n.tag == "Penciller",
-                    n.tag == "Inker",
-                    n.tag == "Colorist",
-                    n.tag == "Letterer",
-                    n.tag == "Editor",
-                ]
-            ):
-                if n.text is not None:
-                    for name in n.text.split(","):
-                        md.add_credit(name.strip(), n.tag)
-
-            if n.tag == "CoverArtist":
-                if n.text is not None:
-                    for name in n.text.split(","):
-                        md.add_credit(name.strip(), "Cover")
-
-        # parse page data now
-        pages_node = root.find("Pages")
-        if pages_node is not None:
-            for page in pages_node:
-                p: dict[str, Any] = page.attrib
-                if "Image" in p:
-                    p["Image"] = int(p["Image"])
-                if "DoublePage" in p:
-                    p["DoublePage"] = True if p["DoublePage"].casefold() in ("yes", "true", "1") else False
-                md.pages.append(cast(ImageMetadata, p))
-
-        md.is_empty = False
-
-        return md
-
-    def write_to_external_file(self, filename: str, metadata: GenericMetadata, xml: bytes = b"") -> None:
-        tree = self.convert_metadata_to_xml(metadata, xml)
-        tree.write(filename, encoding="utf-8", xml_declaration=True)
-
-    def read_from_external_file(self, filename: str) -> GenericMetadata:
-        tree = ET.parse(filename)
-        return self.convert_xml_to_metadata(tree)

comicapi/data/__init__.py

@@ -1,5 +0,0 @@
-from __future__ import annotations
-
-import pathlib
-
-data_path = pathlib.Path(__file__).parent

comicapi/data/publishers.json

@@ -1,130 +0,0 @@
-{
-    "Marvel":{
-        "marvel comics": "",
-        "aircel comics": "Aircel Comics",
-        "aircel": "Aircel Comics",
-        "atlas comics": "Atlas Comics",
-        "atlas": "Atlas Comics",
-        "crossgen comics": "CrossGen comics",
-        "crossgen": "CrossGen comics",
-        "curtis magazines": "Curtis Magazines",
-        "disney books group": "Disney Books Group",
-        "disney books": "Disney Books Group",
-        "disney kingdoms": "Disney Kingdoms",
-        "epic comics group": "Epic Comics",
-        "epic comics": "Epic Comics",
-        "epic": "Epic Comics",
-        "eternity comics": "Eternity Comics",
-        "humorama": "Humorama",
-        "icon comics": "Icon Comics",
-        "infinite comics": "Infinite Comics",
-        "malibu comics": "Malibu Comics",
-        "malibu": "Malibu Comics",
-        "marvel 2099": "Marvel 2099",
-        "marvel absurd": "Marvel Absurd",
-        "marvel adventures": "Marvel Adventures",
-        "marvel age": "Marvel Age",
-        "marvel books": "Marvel Books",
-        "marvel comics 2": "Marvel Comics 2",
-        "marvel digital comics unlimited": "Marvel Unlimited",
-        "marvel edge": "Marvel Edge",
-        "marvel frontier": "Marvel Frontier",
-        "marvel illustrated": "Marvel Illustrated",
-        "marvel knights": "Marvel Knights",
-        "marvel magazine group": "Marvel Magazine Group",
-        "marvel mangaverse": "Marvel Mangaverse",
-        "marvel monsters group": "Marvel Monsters Group",
-        "marvel music": "Marvel Music",
-        "marvel next": "Marvel Next",
-        "marvel noir": "Marvel Noir",
-        "marvel press": "Marvel Press",
-        "marvel uk": "Marvel UK",
-        "marvel unlimited": "Marvel Unlimited",
-        "max": "MAX",
-        "mc2": "Marvel Comics 2",
-        "new universe": "New Universe",
-        "non-pareil publishing corp.": "Non-Pareil Publishing Corp.",
-        "paramount comics": "Paramount Comics",
-        "power comics": "Power Comics",
-        "razorline": "Razorline",
-        "star comics": "Star Comics",
-        "timely comics": "Timely Comics",
-        "timely": "Timely Comics",
-        "tsunami": "Tsunami",
-        "ultimate comics": "Ultimate Comics",
-        "ultimate marvel": "Ultimate Marvel",
-        "vital publications, inc.": "Vital Publications, Inc."
-    },
-
-    "DC Comics":{
-        "dc_comics": "",
-        "dc": "",
-        "dccomics": "",
-        "!mpact comics": "Impact Comics",
-        "all star dc": "All-Star",
-        "all star": "All-Star",
-        "all-star dc": "All-Star",
-        "all-star": "All-Star",
-        "america's best comics": "America's Best Comics",
-        "black label": "DC Black Label",
-        "cliffhanger": "Cliffhanger",
-        "cmx manga": "CMX Manga",
-        "dc black label": "DC Black Label",
-        "dc focus": "DC Focus",
-        "dc ink": "DC Ink",
-        "dc zoom": "DC Zoom",
-        "earth m": "Earth M",
-        "earth one": "Earth One",
-        "earth-m": "Earth M",
-        "elseworlds": "Elseworlds",
-        "eo": "Earth One",
-        "first wave": "First Wave",
-        "focus": "DC Focus",
-        "helix": "Helix",
-        "homage comics": "Homage Comics",
-        "impact comics": "Impact Comics",
-        "impact! comics": "Impact Comics",
-        "johnny dc": "Johnny DC",
-        "mad": "Mad",
-        "minx": "Minx",
-        "paradox press": "Paradox Press",
-        "piranha press": "Piranha Press",
-        "sandman universe": "Sandman Universe",
-        "tangent comics": "Tangent Comics",
-        "tsr": "TSR",
-        "vertigo": "Vertigo",
-        "wildstorm productions": "WildStorm Productions",
-        "wildstorm signature": "WildStorm Productions",
-        "wildstorm": "WildStorm Productions",
-        "wonder comics": "Wonder Comics",
-        "young animal": "Young Animal",
-        "zuda comics": "Zuda Comics",
-        "zuda": "Zuda Comics"
-    },
-
-    "Dark Horse Comics":{
-        "berger books": "Berger Books",
-        "comics' greatest world": "Dark Horse Heroes",
-        "dark horse digital": "Dark Horse Digital",
-        "dark horse heroes": "Dark Horse Heroes",
-        "dark horse manga": "Dark Horse Manga",
-        "dh deluxe": "DH Deluxe",
-        "dh press": "DH Press",
-        "kitchen sink books": "Kitchen Sink Books",
-        "legend": "Legend",
-        "m press": "M Press",
-        "maverick": "Maverick"
-    },
-
-    "Archie Comics":{
-        "archie action": "Archie Action",
-        "archie adventure Series": "Archie Adventure Series",
-        "archie horror": "Archie Horror",
-        "dark circle Comics": "Dark Circle Comics",
-        "dark circle": "Dark Circle Comics",
-        "mighty comics Group": "Mighty Comics Group",
-        "radio comics": "Mighty Comics Group",
-        "red circle Comics": "Dark Circle Comics",
-        "red circle": "Dark Circle Comics"
-    }
-}

comicapi/filenamelexer.py

@@ -1,352 +0,0 @@
-# Extracted and mutilated from https://github.com/lordwelch/wsfmt
-# Which was extracted and mutilated from https://github.com/golang/go/tree/master/src/text/template/parse
-from __future__ import annotations
-
-import calendar
-import os
-import unicodedata
-from enum import Enum, auto
-from typing import Any, Callable
-
-
-class ItemType(Enum):
-    Error = auto()  # Error occurred; value is text of error
-    EOF = auto()
-    Text = auto()  # Text
-    LeftParen = auto()
-    Number = auto()  # Simple number
-    IssueNumber = auto()  # Preceded by a # Symbol
-    RightParen = auto()
-    Space = auto()  # Run of spaces separating arguments
-    Dot = auto()
-    LeftBrace = auto()
-    RightBrace = auto()
-    LeftSBrace = auto()
-    RightSBrace = auto()
-    Symbol = auto()
-    Skip = auto()  # __ or -- no title, issue or series information beyond
-    Operator = auto()
-    Calendar = auto()
-    InfoSpecifier = auto()  # Specifies type of info e.g. v1 for 'volume': 1
-    ArchiveType = auto()
-    Honorific = auto()
-    Keywords = auto()
-    FCBD = auto()
-    ComicType = auto()
-    Publisher = auto()
-    C2C = auto()
-
-
-braces = [
-    ItemType.LeftBrace,
-    ItemType.LeftParen,
-    ItemType.LeftSBrace,
-    ItemType.RightBrace,
-    ItemType.RightParen,
-    ItemType.RightSBrace,
-]
-
-eof = chr(0)
-
-key = {
-    "fcbd": ItemType.FCBD,
-    "freecomicbookday": ItemType.FCBD,
-    "cbr": ItemType.ArchiveType,
-    "cbz": ItemType.ArchiveType,
-    "cbt": ItemType.ArchiveType,
-    "cb7": ItemType.ArchiveType,
-    "rar": ItemType.ArchiveType,
-    "zip": ItemType.ArchiveType,
-    "tar": ItemType.ArchiveType,
-    "7z": ItemType.ArchiveType,
-    "annual": ItemType.ComicType,
-    "volume": ItemType.InfoSpecifier,
-    "vol.": ItemType.InfoSpecifier,
-    "vol": ItemType.InfoSpecifier,
-    "v": ItemType.InfoSpecifier,
-    "of": ItemType.InfoSpecifier,
-    "dc": ItemType.Publisher,
-    "marvel": ItemType.Publisher,
-    "covers": ItemType.InfoSpecifier,
-    "c2c": ItemType.C2C,
-    "mr": ItemType.Honorific,
-    "ms": ItemType.Honorific,
-    "mrs": ItemType.Honorific,
-    "dr": ItemType.Honorific,
-}
-
-
-class Item:
-    def __init__(self, typ: ItemType, pos: int, val: str) -> None:
-        self.typ: ItemType = typ
-        self.pos: int = pos
-        self.val: str = val
-
-    def __repr__(self) -> str:
-        return f"{self.val}: index: {self.pos}: {self.typ}"
-
-
-class Lexer:
-    def __init__(self, string: str) -> None:
-        self.input: str = string  # The string being scanned
-        # The next lexing function to enter
-        self.state: Callable[[Lexer], Callable | None] | None = None  # type: ignore[type-arg]
-        self.pos: int = -1  # Current position in the input
-        self.start: int = 0  # Start position of this item
-        self.lastPos: int = 0  # Position of most recent item returned by nextItem
-        self.paren_depth: int = 0  # Nesting depth of ( ) exprs
-        self.brace_depth: int = 0  # Nesting depth of { }
-        self.sbrace_depth: int = 0  # Nesting depth of [ ]
-        self.items: list[Item] = []
-
-    # Next returns the next rune in the input.
-    def get(self) -> str:
-        if int(self.pos) >= len(self.input) - 1:
-            self.pos += 1
-            return eof
-
-        self.pos += 1
-        return self.input[self.pos]
-
-    # Peek returns but does not consume the next rune in the input.
-    def peek(self) -> str:
-        if int(self.pos) >= len(self.input) - 1:
-            return eof
-
-        return self.input[self.pos + 1]
-
-    def backup(self) -> None:
-        self.pos -= 1
-
-    # Emit passes an item back to the client.
-    def emit(self, t: ItemType) -> None:
-        self.items.append(Item(t, self.start, self.input[self.start : self.pos + 1]))
-        self.start = self.pos + 1
-
-    # Ignore skips over the pending input before this point.
-    def ignore(self) -> None:
-        self.start = self.pos
-
-    # Accept consumes the next rune if it's from the valid se:
-    def accept(self, valid: str) -> bool:
-        if self.get() in valid:
-            return True
-
-        self.backup()
-        return False
-
-    # AcceptRun consumes a run of runes from the valid set.
-    def accept_run(self, valid: str) -> None:
-        while self.get() in valid:
-            continue
-
-        self.backup()
-
-    def scan_number(self) -> bool:
-        digits = "0123456789"
-
-        self.accept_run(digits)
-        if self.accept("."):
-            if self.accept(digits):
-                self.accept_run(digits)
-            else:
-                self.backup()
-        if self.accept("s"):
-            if not self.accept("t"):
-                self.backup()
-        elif self.accept("nr"):
-            if not self.accept("d"):
-                self.backup()
-        elif self.accept("t"):
-            if not self.accept("h"):
-                self.backup()
-
-        return True
-
-    # Runs the state machine for the lexer.
-    def run(self) -> None:
-        self.state = lex_filename
-        while self.state is not None:
-            self.state = self.state(self)
-
-
-# Errorf returns an error token and terminates the scan by passing
-# Back a nil pointer that will be the next state, terminating self.nextItem.
-def errorf(lex: Lexer, message: str) -> Callable[[Lexer], Callable | None] | None:  # type: ignore[type-arg]
-    lex.items.append(Item(ItemType.Error, lex.start, message))
-    return None
-
-
-# Scans the elements inside action delimiters.
-def lex_filename(lex: Lexer) -> Callable[[Lexer], Callable | None] | None:  # type: ignore[type-arg]
-    r = lex.get()
-    if r == eof:
-        if lex.paren_depth != 0:
-            return errorf(lex, "unclosed left paren")
-
-        if lex.brace_depth != 0:
-            return errorf(lex, "unclosed left paren")
-        lex.emit(ItemType.EOF)
-        return None
-    elif is_space(r):
-        if r == "_" and lex.peek() == "_":
-            lex.get()
-            lex.emit(ItemType.Skip)
-        else:
-            return lex_space
-    elif r == ".":
-        r = lex.peek()
-        if r < "0" or "9" < r:
-            lex.emit(ItemType.Dot)
-            return lex_filename
-
-        lex.backup()
-        return lex_number
-    elif r == "'":
-        r = lex.peek()
-        if r in "0123456789":
-            return lex_number
-        lex.emit(ItemType.Text)  # TODO: Change to Text
-    elif "0" <= r <= "9":
-        lex.backup()
-        return lex_number
-    elif r == "#":
-        if "0" <= lex.peek() <= "9":
-            return lex_number
-        lex.emit(ItemType.Symbol)
-    elif is_operator(r):
-        if r == "-" and lex.peek() == "-":
-            lex.get()
-            lex.emit(ItemType.Skip)
-        else:
-            return lex_operator
-    elif is_alpha_numeric(r):
-        lex.backup()
-        return lex_text
-    elif r == "(":
-        lex.emit(ItemType.LeftParen)
-        lex.paren_depth += 1
-    elif r == ")":
-        lex.emit(ItemType.RightParen)
-        lex.paren_depth -= 1
-        if lex.paren_depth < 0:
-            return errorf(lex, "unexpected right paren " + r)
-
-    elif r == "{":
-        lex.emit(ItemType.LeftBrace)
-        lex.brace_depth += 1
-    elif r == "}":
-        lex.emit(ItemType.RightBrace)
-        lex.brace_depth -= 1
-        if lex.brace_depth < 0:
-            return errorf(lex, "unexpected right brace " + r)
-
-    elif r == "[":
-        lex.emit(ItemType.LeftSBrace)
-        lex.sbrace_depth += 1
-    elif r == "]":
-        lex.emit(ItemType.RightSBrace)
-        lex.sbrace_depth -= 1
-        if lex.sbrace_depth < 0:
-            return errorf(lex, "unexpected right brace " + r)
-    elif is_symbol(r):
-        lex.emit(ItemType.Symbol)
-    else:
-        return errorf(lex, "unrecognized character in action: " + r)
-
-    return lex_filename
-
-
-def lex_operator(lex: Lexer) -> Callable:  # type: ignore[type-arg]
-    lex.accept_run("-|:;")
-    lex.emit(ItemType.Operator)
-    return lex_filename
-
-
-# LexSpace scans a run of space characters.
-# One space has already been seen.
-def lex_space(lex: Lexer) -> Callable:  # type: ignore[type-arg]
-    while is_space(lex.peek()):
-        lex.get()
-
-    lex.emit(ItemType.Space)
-    return lex_filename
-
-
-# Lex_text scans an alphanumeric.
-def lex_text(lex: Lexer) -> Callable:  # type: ignore[type-arg]
-    while True:
-        r = lex.get()
-        if is_alpha_numeric(r):
-            if r.isnumeric():  # E.g. v1
-                word = lex.input[lex.start : lex.pos]
-                if word.casefold() in key and key[word.casefold()] == ItemType.InfoSpecifier:
-                    lex.backup()
-                    lex.emit(key[word.casefold()])
-                    return lex_filename
-        else:
-            if r == "'" and lex.peek() == "s":
-                lex.get()
-            else:
-                lex.backup()
-            word = lex.input[lex.start : lex.pos + 1]
-            if word.casefold() == "vol" and lex.peek() == ".":
-                lex.get()
-            word = lex.input[lex.start : lex.pos + 1]
-
-            if word.casefold() in key:
-                lex.emit(key[word.casefold()])
-            elif cal(word):
-                lex.emit(ItemType.Calendar)
-            else:
-                lex.emit(ItemType.Text)
-            break
-
-    return lex_filename
-
-
-def cal(value: str) -> set[Any]:
-    month_abbr = [i for i, x in enumerate(calendar.month_abbr) if x == value.title()]
-    month_name = [i for i, x in enumerate(calendar.month_name) if x == value.title()]
-    day_abbr = [i for i, x in enumerate(calendar.day_abbr) if x == value.title()]
-    day_name = [i for i, x in enumerate(calendar.day_name) if x == value.title()]
-    return set(month_abbr + month_name + day_abbr + day_name)
-
-
-def lex_number(lex: Lexer) -> Callable[[Lexer], Callable | None] | None:  # type: ignore[type-arg]
-    if not lex.scan_number():
-        return errorf(lex, "bad number syntax: " + lex.input[lex.start : lex.pos])
-    # Complex number logic removed. Messes with math operations without space
-
-    if lex.input[lex.start] == "#":
-        lex.emit(ItemType.IssueNumber)
-    elif not lex.input[lex.pos].isdigit():
-        # Assume that 80th is just text and not a number
-        lex.emit(ItemType.Text)
-    else:
-        lex.emit(ItemType.Number)
-
-    return lex_filename
-
-
-def is_space(character: str) -> bool:
-    return character in "_ \t"
-
-
-# IsAlphaNumeric reports whether r is an alphabetic, digit, or underscore.
-def is_alpha_numeric(character: str) -> bool:
-    return character.isalpha() or character.isnumeric()
-
-
-def is_operator(character: str) -> bool:
-    return character in "-|:;/\\"
-
-
-def is_symbol(character: str) -> bool:
-    return unicodedata.category(character)[0] in "PS"
-
-
-def Lex(filename: str) -> Lexer:
-    lex = Lexer(string=os.path.basename(filename))
-    lex.run()
-    return lex

comicapi/genericmetadata.py

@@ -1,461 +0,0 @@
-"""A class for internal metadata storage
-
-The goal of this class is to handle ALL the data that might come from various
-tagging schemes and databases, such as ComicVine or GCD.  This makes conversion
-possible, however lossy it might be
-
-"""
-# Copyright 2012-2014 ComicTagger Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-from __future__ import annotations
-
-import copy
-import dataclasses
-import logging
-from typing import Any, TypedDict
-
-from comicapi import utils
-
-logger = logging.getLogger(__name__)
-
-
-class PageType:
-
-    """
-    These page info classes are exactly the same as the CIX scheme, since
-    it's unique
-    """
-
-    FrontCover = "FrontCover"
-    InnerCover = "InnerCover"
-    Roundup = "Roundup"
-    Story = "Story"
-    Advertisement = "Advertisement"
-    Editorial = "Editorial"
-    Letters = "Letters"
-    Preview = "Preview"
-    BackCover = "BackCover"
-    Other = "Other"
-    Deleted = "Deleted"
-
-
-class ImageMetadata(TypedDict, total=False):
-    Type: str
-    Bookmark: str
-    DoublePage: bool
-    Image: int
-    ImageSize: str
-    ImageHeight: str
-    ImageWidth: str
-
-
-class CreditMetadata(TypedDict):
-    person: str
-    role: str
-    primary: bool
-
-
-@dataclasses.dataclass
-class GenericMetadata:
-    writer_synonyms = ["writer", "plotter", "scripter"]
-    penciller_synonyms = ["artist", "penciller", "penciler", "breakdowns"]
-    inker_synonyms = ["inker", "artist", "finishes"]
-    colorist_synonyms = ["colorist", "colourist", "colorer", "colourer"]
-    letterer_synonyms = ["letterer"]
-    cover_synonyms = ["cover", "covers", "coverartist", "cover artist"]
-    editor_synonyms = ["editor"]
-
-    is_empty: bool = True
-    tag_origin: str | None = None
-    issue_id: str | None = None
-
-    series: str | None = None
-    issue: str | None = None
-    title: str | None = None
-    publisher: str | None = None
-    month: int | None = None
-    year: int | None = None
-    day: int | None = None
-    issue_count: int | None = None
-    volume: int | None = None
-    genre: str | None = None
-    language: str | None = None  # 2 letter iso code
-    comments: str | None = None  # use same way as Summary in CIX
-
-    volume_count: int | None = None
-    critical_rating: float | None = None  # rating in CBL; CommunityRating in CIX
-    country: str | None = None
-
-    alternate_series: str | None = None
-    alternate_number: str | None = None
-    alternate_count: int | None = None
-    imprint: str | None = None
-    notes: str | None = None
-    web_link: str | None = None
-    format: str | None = None
-    manga: str | None = None
-    black_and_white: bool | None = None
-    page_count: int | None = None
-    maturity_rating: str | None = None
-
-    story_arc: str | None = None
-    series_group: str | None = None
-    scan_info: str | None = None
-
-    characters: str | None = None
-    teams: str | None = None
-    locations: str | None = None
-
-    credits: list[CreditMetadata] = dataclasses.field(default_factory=list)
-    tags: set[str] = dataclasses.field(default_factory=set)
-    pages: list[ImageMetadata] = dataclasses.field(default_factory=list)
-
-    # Some CoMet-only items
-    price: str | None = None
-    is_version_of: str | None = None
-    rights: str | None = None
-    identifier: str | None = None
-    last_mark: str | None = None
-    cover_image: str | None = None
-
-    def __post_init__(self) -> None:
-        for key, value in self.__dict__.items():
-            if value and key != "is_empty":
-                self.is_empty = False
-                break
-
-    def copy(self) -> GenericMetadata:
-        return copy.deepcopy(self)
-
-    def replace(self, /, **kwargs: Any) -> GenericMetadata:
-        tmp = self.copy()
-        tmp.__dict__.update(kwargs)
-        return tmp
-
-    def overlay(self, new_md: GenericMetadata) -> None:
-        """Overlay a metadata object on this one
-
-        That is, when the new object has non-None values, over-write them
-        to this one.
-        """
-
-        def assign(cur: str, new: Any) -> None:
-            if new is not None:
-                if isinstance(new, str) and len(new) == 0:
-                    setattr(self, cur, None)
-                else:
-                    setattr(self, cur, new)
-
-        if not new_md.is_empty:
-            self.is_empty = False
-
-        assign("series", new_md.series)
-        assign("issue", new_md.issue)
-        assign("issue_count", new_md.issue_count)
-        assign("title", new_md.title)
-        assign("publisher", new_md.publisher)
-        assign("day", new_md.day)
-        assign("month", new_md.month)
-        assign("year", new_md.year)
-        assign("volume", new_md.volume)
-        assign("volume_count", new_md.volume_count)
-        assign("genre", new_md.genre)
-        assign("language", new_md.language)
-        assign("country", new_md.country)
-        assign("critical_rating", new_md.critical_rating)
-        assign("alternate_series", new_md.alternate_series)
-        assign("alternate_number", new_md.alternate_number)
-        assign("alternate_count", new_md.alternate_count)
-        assign("imprint", new_md.imprint)
-        assign("web_link", new_md.web_link)
-        assign("format", new_md.format)
-        assign("manga", new_md.manga)
-        assign("black_and_white", new_md.black_and_white)
-        assign("maturity_rating", new_md.maturity_rating)
-        assign("story_arc", new_md.story_arc)
-        assign("series_group", new_md.series_group)
-        assign("scan_info", new_md.scan_info)
-        assign("characters", new_md.characters)
-        assign("teams", new_md.teams)
-        assign("locations", new_md.locations)
-        assign("comments", new_md.comments)
-        assign("notes", new_md.notes)
-
-        assign("price", new_md.price)
-        assign("is_version_of", new_md.is_version_of)
-        assign("rights", new_md.rights)
-        assign("identifier", new_md.identifier)
-        assign("last_mark", new_md.last_mark)
-
-        self.overlay_credits(new_md.credits)
-        # TODO
-
-        # not sure if the tags and pages should broken down, or treated
-        # as whole lists....
-
-        # For now, go the easy route, where any overlay
-        # value wipes out the whole list
-        if len(new_md.tags) > 0:
-            assign("tags", new_md.tags)
-
-        if len(new_md.pages) > 0:
-            assign("pages", new_md.pages)
-
-    def overlay_credits(self, new_credits: list[CreditMetadata]) -> None:
-        for c in new_credits:
-            primary = bool("primary" in c and c["primary"])
-
-            # Remove credit role if person is blank
-            if c["person"] == "":
-                for r in reversed(self.credits):
-                    if r["role"].casefold() == c["role"].casefold():
-                        self.credits.remove(r)
-            # otherwise, add it!
-            else:
-                self.add_credit(c["person"], c["role"], primary)
-
-    def set_default_page_list(self, count: int) -> None:
-        # generate a default page list, with the first page marked as the cover
-        for i in range(count):
-            page_dict = ImageMetadata(Image=i)
-            if i == 0:
-                page_dict["Type"] = PageType.FrontCover
-            self.pages.append(page_dict)
-
-    def get_archive_page_index(self, pagenum: int) -> int:
-        # convert the displayed page number to the page index of the file in the archive
-        if pagenum < len(self.pages):
-            return int(self.pages[pagenum]["Image"])
-
-        return 0
-
-    def get_cover_page_index_list(self) -> list[int]:
-        # return a list of archive page indices of cover pages
-        coverlist = []
-        for p in self.pages:
-            if "Type" in p and p["Type"] == PageType.FrontCover:
-                coverlist.append(int(p["Image"]))
-
-        if len(coverlist) == 0:
-            coverlist.append(0)
-
-        return coverlist
-
-    def add_credit(self, person: str, role: str, primary: bool = False) -> None:
-        credit = CreditMetadata(person=person, role=role, primary=primary)
-
-        # look to see if it's not already there...
-        found = False
-        for c in self.credits:
-            if c["person"].casefold() == person.casefold() and c["role"].casefold() == role.casefold():
-                # no need to add it. just adjust the "primary" flag as needed
-                c["primary"] = primary
-                found = True
-                break
-
-        if not found:
-            self.credits.append(credit)
-
-    def get_primary_credit(self, role: str) -> str:
-        primary = ""
-        for credit in self.credits:
-            if "role" not in credit or "person" not in credit:
-                continue
-            if (primary == "" and credit["role"].casefold() == role.casefold()) or (
-                credit["role"].casefold() == role.casefold() and "primary" in credit and credit["primary"]
-            ):
-                primary = credit["person"]
-        return primary
-
-    def __str__(self) -> str:
-        vals: list[tuple[str, Any]] = []
-        if self.is_empty:
-            return "No metadata"
-
-        def add_string(tag: str, val: Any) -> None:
-            if val is not None and str(val) != "":
-                vals.append((tag, val))
-
-        def add_attr_string(tag: str) -> None:
-            add_string(tag, getattr(self, tag))
-
-        add_attr_string("series")
-        add_attr_string("issue")
-        add_attr_string("issue_count")
-        add_attr_string("title")
-        add_attr_string("publisher")
-        add_attr_string("year")
-        add_attr_string("month")
-        add_attr_string("day")
-        add_attr_string("volume")
-        add_attr_string("volume_count")
-        add_attr_string("genre")
-        add_attr_string("language")
-        add_attr_string("country")
-        add_attr_string("critical_rating")
-        add_attr_string("alternate_series")
-        add_attr_string("alternate_number")
-        add_attr_string("alternate_count")
-        add_attr_string("imprint")
-        add_attr_string("web_link")
-        add_attr_string("format")
-        add_attr_string("manga")
-
-        add_attr_string("price")
-        add_attr_string("is_version_of")
-        add_attr_string("rights")
-        add_attr_string("identifier")
-        add_attr_string("last_mark")
-
-        if self.black_and_white:
-            add_attr_string("black_and_white")
-        add_attr_string("maturity_rating")
-        add_attr_string("story_arc")
-        add_attr_string("series_group")
-        add_attr_string("scan_info")
-        add_attr_string("characters")
-        add_attr_string("teams")
-        add_attr_string("locations")
-        add_attr_string("comments")
-        add_attr_string("notes")
-
-        add_string("tags", ", ".join(self.tags))
-
-        for c in self.credits:
-            primary = ""
-            if "primary" in c and c["primary"]:
-                primary = " [P]"
-            add_string("credit", c["role"] + ": " + c["person"] + primary)
-
-        # find the longest field name
-        flen = 0
-        for i in vals:
-            flen = max(flen, len(i[0]))
-        flen += 1
-
-        # format the data nicely
-        outstr = ""
-        fmt_str = "{0: <" + str(flen) + "} {1}\n"
-        for i in vals:
-            outstr += fmt_str.format(i[0] + ":", i[1])
-
-        return outstr
-
-    def fix_publisher(self) -> None:
-        if self.publisher is None:
-            return
-        if self.imprint is None:
-            self.imprint = ""
-
-        imprint, publisher = utils.get_publisher(self.publisher)
-
-        self.publisher = publisher
-
-        if self.imprint.casefold() in publisher.casefold():
-            self.imprint = None
-
-        if self.imprint is None or self.imprint == "":
-            self.imprint = imprint
-        elif self.imprint.casefold() in imprint.casefold():
-            self.imprint = imprint
-
-
-md_test: GenericMetadata = GenericMetadata(
-    is_empty=False,
-    tag_origin=None,
-    series="Cory Doctorow's Futuristic Tales of the Here and Now",
-    issue="1",
-    title="Anda's Game",
-    publisher="IDW Publishing",
-    month=10,
-    year=2007,
-    day=1,
-    issue_count=6,
-    volume=1,
-    genre="Sci-Fi",
-    language="en",
-    comments=(
-        "For 12-year-old Anda, getting paid real money to kill the characters of players who were cheating"
-        " in her favorite online computer game was a win-win situation. Until she found out who was paying her,"
-        " and what those characters meant to the livelihood of children around the world."
-    ),
-    volume_count=None,
-    critical_rating=3.0,
-    country=None,
-    alternate_series="Tales",
-    alternate_number="2",
-    alternate_count=7,
-    imprint="craphound.com",
-    notes="Tagged with ComicTagger 1.3.2a5 using info from Comic Vine on 2022-04-16 15:52:26. [Issue ID 140529]",
-    web_link="https://comicvine.gamespot.com/cory-doctorows-futuristic-tales-of-the-here-and-no/4000-140529/",
-    format="Series",
-    manga="No",
-    black_and_white=None,
-    page_count=24,
-    maturity_rating="Everyone 10+",
-    story_arc="Here and Now",
-    series_group="Futuristic Tales",
-    scan_info="(CC BY-NC-SA 3.0)",
-    characters="Anda",
-    teams="Fahrenheit",
-    locations="lonely  cottage ",
-    credits=[
-        CreditMetadata(primary=False, person="Dara Naraghi", role="Writer"),
-        CreditMetadata(primary=False, person="Esteve Polls", role="Penciller"),
-        CreditMetadata(primary=False, person="Esteve Polls", role="Inker"),
-        CreditMetadata(primary=False, person="Neil Uyetake", role="Letterer"),
-        CreditMetadata(primary=False, person="Sam Kieth", role="Cover"),
-        CreditMetadata(primary=False, person="Ted Adams", role="Editor"),
-    ],
-    tags=set(),
-    pages=[
-        ImageMetadata(Image=0, ImageHeight="1280", ImageSize="195977", ImageWidth="800", Type=PageType.FrontCover),
-        ImageMetadata(Image=1, ImageHeight="2039", ImageSize="611993", ImageWidth="1327"),
-        ImageMetadata(Image=2, ImageHeight="2039", ImageSize="783726", ImageWidth="1327"),
-        ImageMetadata(Image=3, ImageHeight="2039", ImageSize="679584", ImageWidth="1327"),
-        ImageMetadata(Image=4, ImageHeight="2039", ImageSize="788179", ImageWidth="1327"),
-        ImageMetadata(Image=5, ImageHeight="2039", ImageSize="864433", ImageWidth="1327"),
-        ImageMetadata(Image=6, ImageHeight="2039", ImageSize="765606", ImageWidth="1327"),
-        ImageMetadata(Image=7, ImageHeight="2039", ImageSize="876427", ImageWidth="1327"),
-        ImageMetadata(Image=8, ImageHeight="2039", ImageSize="852622", ImageWidth="1327"),
-        ImageMetadata(Image=9, ImageHeight="2039", ImageSize="800205", ImageWidth="1327"),
-        ImageMetadata(Image=10, ImageHeight="2039", ImageSize="746243", ImageWidth="1326"),
-        ImageMetadata(Image=11, ImageHeight="2039", ImageSize="718062", ImageWidth="1327"),
-        ImageMetadata(Image=12, ImageHeight="2039", ImageSize="532179", ImageWidth="1326"),
-        ImageMetadata(Image=13, ImageHeight="2039", ImageSize="686708", ImageWidth="1327"),
-        ImageMetadata(Image=14, ImageHeight="2039", ImageSize="641907", ImageWidth="1327"),
-        ImageMetadata(Image=15, ImageHeight="2039", ImageSize="805388", ImageWidth="1327"),
-        ImageMetadata(Image=16, ImageHeight="2039", ImageSize="668927", ImageWidth="1326"),
-        ImageMetadata(Image=17, ImageHeight="2039", ImageSize="710605", ImageWidth="1327"),
-        ImageMetadata(Image=18, ImageHeight="2039", ImageSize="761398", ImageWidth="1326"),
-        ImageMetadata(Image=19, ImageHeight="2039", ImageSize="743807", ImageWidth="1327"),
-        ImageMetadata(Image=20, ImageHeight="2039", ImageSize="552911", ImageWidth="1326"),
-        ImageMetadata(Image=21, ImageHeight="2039", ImageSize="556827", ImageWidth="1327"),
-        ImageMetadata(Image=22, ImageHeight="2039", ImageSize="675078", ImageWidth="1326"),
-        ImageMetadata(
-            Bookmark="Interview",
-            Image=23,
-            ImageHeight="2032",
-            ImageSize="800965",
-            ImageWidth="1338",
-            Type=PageType.Letters,
-        ),
-    ],
-    price=None,
-    is_version_of=None,
-    rights=None,
-    identifier=None,
-    last_mark=None,
-    cover_image=None,
-)

comicapi/issuestring.py

@@ -1,115 +0,0 @@
-"""Support for mixed digit/string type Issue field
-
-Class for handling the odd permutations of an 'issue number' that the
-comics industry throws at us.
-  e.g.: "12", "12.1", "0", "-1", "5AU", "100-2"
-"""
-# Copyright 2012-2014 ComicTagger Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-from __future__ import annotations
-
-import logging
-import unicodedata
-
-logger = logging.getLogger(__name__)
-
-
-class IssueString:
-    def __init__(self, text: str | None) -> None:
-        # break up the issue number string into 2 parts: the numeric and suffix string.
-        # (assumes that the numeric portion is always first)
-
-        self.num = None
-        self.suffix = ""
-
-        if text is None:
-            return
-
-        text = str(text)
-
-        if len(text) == 0:
-            return
-
-        # skip the minus sign if it's first
-        if text[0] == "-":
-            start = 1
-        else:
-            start = 0
-
-        # if it's still not numeric at start skip it
-        if text[start].isdigit() or text[start] == ".":
-            # walk through the string, look for split point (the first non-numeric)
-            decimal_count = 0
-            for idx in range(start, len(text)):
-                if text[idx] not in "0123456789.":
-                    break
-                # special case: also split on second "."
-                if text[idx] == ".":
-                    decimal_count += 1
-                    if decimal_count > 1:
-                        break
-            else:
-                idx = len(text)
-
-            # move trailing numeric decimal to suffix
-            # (only if there is other junk after )
-            if text[idx - 1] == "." and len(text) != idx:
-                idx = idx - 1
-
-            # if there is no numeric after the minus, make the minus part of the suffix
-            if idx == 1 and start == 1:
-                idx = 0
-
-            part1 = text[0:idx]
-            part2 = text[idx : len(text)]
-
-            if part1 != "":
-                self.num = float(part1)
-            self.suffix = part2
-        else:
-            self.suffix = text
-
-    def as_string(self, pad: int = 0) -> str:
-        # return the float, left side zero-padded, with suffix attached
-        if self.num is None:
-            return self.suffix
-
-        negative = self.num < 0
-
-        num_f = abs(self.num)
-
-        num_int = int(num_f)
-        num_s = str(num_int)
-        if float(num_int) != num_f:
-            num_s = str(num_f)
-
-        num_s += self.suffix
-
-        # create padding
-        padding = ""
-        length = len(str(num_int))
-        if length < pad:
-            padding = "0" * (pad - length)
-
-        num_s = padding + num_s
-        if negative:
-            num_s = "-" + num_s
-
-        return num_s
-
-    def as_float(self) -> float | None:
-        # return the float, with no suffix
-        if len(self.suffix) == 1 and self.suffix.isnumeric():
-            return (self.num or 0) + unicodedata.numeric(self.suffix)
-        return self.num

comicapi/utils.py

@@ -1,296 +0,0 @@
-"""Some generic utilities"""
-# Copyright 2012-2014 ComicTagger Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-from __future__ import annotations
-
-import json
-import logging
-import os
-import pathlib
-import platform
-import unicodedata
-from collections import defaultdict
-from collections.abc import Iterable, Mapping
-from shutil import which  # noqa: F401
-from typing import Any
-
-import natsort
-import pycountry
-import rapidfuzz.fuzz
-
-import comicapi.data
-
-try:
-    import icu
-
-    del icu
-    icu_available = True
-except ImportError:
-    icu_available = False
-
-logger = logging.getLogger(__name__)
-
-
-def _custom_key(tup):
-    lst = []
-    for x in natsort.os_sort_keygen()(tup):
-        ret = x
-        if len(x) > 1 and isinstance(x[1], int) and isinstance(x[0], str) and x[0] == "":
-            ret = ("a", *x[1:])
-
-        lst.append(ret)
-    return tuple(lst)
-
-
-def os_sorted(lst: Iterable) -> Iterable:
-    key = _custom_key
-    if icu_available or platform.system() == "Windows":
-        key = natsort.os_sort_keygen()
-    return sorted(lst, key=key)
-
-
-def combine_notes(existing_notes: str | None, new_notes: str | None, split: str) -> str:
-    split_notes, split_str, untouched_notes = (existing_notes or "").rpartition(split)
-    if split_notes or split_str:
-        return (split_notes + (new_notes or "")).strip()
-    else:
-        return (untouched_notes + "\n" + (new_notes or "")).strip()
-
-
-def parse_date_str(date_str: str) -> tuple[int | None, int | None, int | None]:
-    day = None
-    month = None
-    year = None
-    if date_str:
-        parts = date_str.split("-")
-        year = xlate(parts[0], True)
-        if len(parts) > 1:
-            month = xlate(parts[1], True)
-            if len(parts) > 2:
-                day = xlate(parts[2], True)
-    return day, month, year
-
-
-def get_recursive_filelist(pathlist: list[str]) -> list[str]:
-    """Get a recursive list of of all files under all path items in the list"""
-
-    filelist: list[str] = []
-    for p in pathlist:
-        if os.path.isdir(p):
-            for root, _, files in os.walk(p):
-                for f in files:
-                    filelist.append(os.path.join(root, f))
-        else:
-            filelist.append(p)
-
-    return filelist
-
-
-def add_to_path(dirname: str) -> None:
-    if dirname:
-        dirname = os.path.abspath(dirname)
-        paths = [os.path.normpath(x) for x in os.environ["PATH"].split(os.pathsep)]
-
-        if dirname not in paths:
-            paths.insert(0, dirname)
-            os.environ["PATH"] = os.pathsep.join(paths)
-
-
-def xlate(data: Any, is_int: bool = False, is_float: bool = False) -> Any:
-    if data is None or data == "":
-        return None
-    if is_int or is_float:
-        i: str | int | float
-        if isinstance(data, (int, float)):
-            i = data
-        else:
-            i = str(data).translate(defaultdict(lambda: None, zip((ord(c) for c in "1234567890."), "1234567890.")))
-        if i == "":
-            return None
-        try:
-            if is_float:
-                return float(i)
-            return int(float(i))
-        except ValueError:
-            return None
-
-    return str(data)
-
-
-def remove_articles(text: str) -> str:
-    text = text.casefold()
-    articles = [
-        "&",
-        "a",
-        "am",
-        "an",
-        "and",
-        "as",
-        "at",
-        "be",
-        "but",
-        "by",
-        "for",
-        "if",
-        "is",
-        "issue",
-        "it",
-        "it's",
-        "its",
-        "itself",
-        "of",
-        "or",
-        "so",
-        "the",
-        "the",
-        "with",
-    ]
-    new_text = ""
-    for word in text.split():
-        if word not in articles:
-            new_text += word + " "
-
-    new_text = new_text[:-1]
-
-    return new_text
-
-
-def sanitize_title(text: str, basic: bool = False) -> str:
-    # normalize unicode and convert to ascii. Does not work for everything eg ½ to 1⁄2 not 1/2
-    text = unicodedata.normalize("NFKD", text).casefold()
-    # comicvine keeps apostrophes a part of the word
-    text = text.replace("'", "")
-    text = text.replace('"', "")
-    if not basic:
-        # comicvine ignores punctuation and accents
-        # remove all characters that are not a letter, separator (space) or number
-        # replace any "dash punctuation" with a space
-        # makes sure that batman-superman and self-proclaimed stay separate words
-        text = "".join(
-            c if unicodedata.category(c)[0] not in "P" else " " for c in text if unicodedata.category(c)[0] in "LZNP"
-        )
-        # remove extra space and articles and all lower case
-        text = remove_articles(text).strip()
-
-    return text
-
-
-def titles_match(search_title: str, record_title: str, threshold: int = 90) -> bool:
-    sanitized_search = sanitize_title(search_title)
-    sanitized_record = sanitize_title(record_title)
-    ratio = int(rapidfuzz.fuzz.ratio(sanitized_search, sanitized_record))
-    logger.debug(
-        "search title: %s ; record title: %s ; ratio: %d ; match threshold: %d",
-        search_title,
-        record_title,
-        ratio,
-        threshold,
-    )
-    return ratio >= threshold
-
-
-def unique_file(file_name: pathlib.Path) -> pathlib.Path:
-    name = file_name.stem
-    counter = 1
-    while True:
-        if not file_name.exists():
-            return file_name
-        file_name = file_name.with_stem(name + " (" + str(counter) + ")")
-        counter += 1
-
-
-languages: dict[str | None, str | None] = defaultdict(lambda: None)
-
-countries: dict[str | None, str | None] = defaultdict(lambda: None)
-
-for c in pycountry.countries:
-    if "alpha_2" in c._fields:
-        countries[c.alpha_2] = c.name
-
-for lng in pycountry.languages:
-    if "alpha_2" in lng._fields:
-        languages[lng.alpha_2] = lng.name
-
-
-def get_language_from_iso(iso: str | None) -> str | None:
-    return languages[iso]
-
-
-def get_language_iso(string: str | None) -> str | None:
-    if string is None:
-        return None
-    lang = string.casefold()
-
-    try:
-        return getattr(pycountry.languages.lookup(string), "alpha_2", None)
-    except LookupError:
-        pass
-    return lang
-
-
-def get_publisher(publisher: str) -> tuple[str, str]:
-    imprint = ""
-
-    for pub in publishers.values():
-        imprint, publisher, ok = pub[publisher]
-        if ok:
-            break
-
-    return (imprint, publisher)
-
-
-def update_publishers(new_publishers: Mapping[str, Mapping[str, str]]) -> None:
-    for publisher in new_publishers:
-        if publisher in publishers:
-            publishers[publisher].update(new_publishers[publisher])
-        else:
-            publishers[publisher] = ImprintDict(publisher, new_publishers[publisher])
-
-
-class ImprintDict(dict):  # type: ignore
-    """
-    ImprintDict takes a publisher and a dict or mapping of lowercased
-    imprint names to the proper imprint name. Retrieving a value from an
-    ImprintDict returns a tuple of (imprint, publisher, keyExists).
-    if the key does not exist the key is returned as the publisher unchanged
-    """
-
-    def __init__(self, publisher: str, mapping: tuple | Mapping = (), **kwargs: dict) -> None:  # type: ignore
-        super().__init__(mapping, **kwargs)
-        self.publisher = publisher
-
-    def __missing__(self, key: str) -> None:
-        return None
-
-    def __getitem__(self, k: str) -> tuple[str, str, bool]:
-        item = super().__getitem__(k.casefold())
-        if k.casefold() == self.publisher.casefold():
-            return ("", self.publisher, True)
-        if item is None:
-            return ("", k, False)
-        else:
-            return (item, self.publisher, True)
-
-    def copy(self) -> ImprintDict:
-        return ImprintDict(self.publisher, super().copy())
-
-
-publishers: dict[str, ImprintDict] = {}
-
-
-def load_publishers() -> None:
-    try:
-        update_publishers(json.loads((comicapi.data.data_path / "publishers.json").read_text("utf-8")))
-    except Exception:
-        logger.exception("Failed to load publishers.json; The are no publishers or imprints loaded")

comictagger.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python3
+from comictaggerlib.main import ctmain
+
+if __name__ == "__main__":
+    ctmain()

comictagger.sublime-project

@@ -0,0 +1,17 @@
+{
+	"build_systems":
+	[
+		{
+			"file_regex": "^[ ]*File \"(...*?)\", line ([0-9]*)",
+			"name": "Anaconda Python Builder",
+			"selector": "source.python",
+			"shell_cmd": "\"python3\" -u \"$file\""
+		}
+	],
+	"folders":
+	[
+		{
+			"path": "."
+		}
+	]
+}

comictaggerlib/__init__.py

@@ -1 +1 @@
-from __future__ import annotations
+from ._version import version as __version__

comictaggerlib/__main__.py

@@ -1,5 +0,0 @@
-from __future__ import annotations
-
-from comictaggerlib.main import main
-
-main()

comictaggerlib/__pyinstaller/__init__.py

@@ -1,11 +0,0 @@
-from __future__ import annotations
-
-import os
-
-import comicapi.__pyinstaller
-
-
-def get_hook_dirs() -> list[str]:
-    hooks = [os.path.dirname(__file__)]
-    hooks.extend(comicapi.__pyinstaller.get_hook_dirs())
-    return hooks

comictaggerlib/__pyinstaller/hook-comictaggerlib.py

@@ -1,7 +0,0 @@
-from __future__ import annotations
-
-from PyInstaller.utils.hooks import collect_data_files, collect_entry_point
-
-datas, hiddenimports = collect_entry_point("comictagger.talker")
-datas += collect_data_files("comictaggerlib.ui")
-datas += collect_data_files("comictaggerlib.graphics")

comictaggerlib/__pyinstaller/hook-wordninja.py

@@ -1,7 +0,0 @@
-from __future__ import annotations
-
-import os
-
-from PyInstaller.utils.hooks import get_module_file_attribute
-
-datas = [(os.path.join(os.path.dirname(get_module_file_attribute("wordninja")), "wordninja"), "wordninja")]

comictaggerlib/applicationlogwindow.py

@@ -1,50 +0,0 @@
-from __future__ import annotations
-
-import logging
-
-from PyQt5 import QtCore, QtGui, QtWidgets, uic
-
-from comictaggerlib.ui import ui_path
-
-logger = logging.getLogger(__name__)
-
-
-class QTextEditLogger(QtCore.QObject, logging.Handler):
-    qlog = QtCore.pyqtSignal(str)
-
-    def __init__(self, formatter: logging.Formatter, level: int) -> None:
-        super().__init__()
-        self.setFormatter(formatter)
-        self.setLevel(level)
-
-    def emit(self, record: logging.LogRecord) -> None:
-        msg = self.format(record)
-        self.qlog.emit(msg.strip())
-
-
-class ApplicationLogWindow(QtWidgets.QDialog):
-    def __init__(self, log_handler: QTextEditLogger, parent: QtCore.QObject | None = None) -> None:
-        super().__init__(parent)
-        uic.loadUi(ui_path / "logwindow.ui", self)
-
-        self.log_handler = log_handler
-        self.log_handler.qlog.connect(self.textEdit.append)
-
-        f = QtGui.QFont("menlo")
-        f.setStyleHint(QtGui.QFont.Monospace)
-        self.setFont(f)
-        self._button = QtWidgets.QPushButton(self)
-        self._button.setText("Test Me")
-
-        layout = self.layout()
-        layout.addWidget(self._button)
-
-        # Connect signal to slot
-        self._button.clicked.connect(self.test)
-        self.textEdit.setTabStopDistance(self.textEdit.tabStopDistance() * 2)
-
-    def test(self) -> None:
-        logger.debug("damn, a bug")
-        logger.info("something to remember")
-        logger.warning("that's not right")
-        logger.error("foobar")

comictaggerlib/autotagmatchwindow.py

@@ -1,121 +1,93 @@
 """A PyQT4 dialog to select from automated issue matches"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import logging
 import os
-from typing import Callable
 
-import settngs
 from PyQt5 import QtCore, QtGui, QtWidgets, uic
 
-from comicapi.comicarchive import MetaDataStyle
-from comicapi.genericmetadata import GenericMetadata
-from comictaggerlib.coverimagewidget import CoverImageWidget
-from comictaggerlib.resulttypes import IssueResult, MultipleMatch
-from comictaggerlib.ui import ui_path
-from comictaggerlib.ui.qtutils import reduce_widget_font_size
-from comictalker.comictalker import ComicTalker
+from comictaggerlib.ui.qtutils import reduceWidgetFontSize
 
-logger = logging.getLogger(__name__)
+from .comicarchive import MetaDataStyle
+from .coverimagewidget import CoverImageWidget
+from .settings import ComicTaggerSettings
 
 
 class AutoTagMatchWindow(QtWidgets.QDialog):
-    def __init__(
-        self,
-        parent: QtWidgets.QWidget,
-        match_set_list: list[MultipleMatch],
-        style: int,
-        fetch_func: Callable[[IssueResult], GenericMetadata],
-        config: settngs.Namespace,
-        talker: ComicTalker,
-    ) -> None:
-        super().__init__(parent)
 
-        uic.loadUi(ui_path / "matchselectionwindow.ui", self)
+    volume_id = 0
 
-        self.config = config
+    def __init__(self, parent, match_set_list, style, fetch_func):
+        super(AutoTagMatchWindow, self).__init__(parent)
 
-        self.current_match_set: MultipleMatch = match_set_list[0]
+        uic.loadUi(ComicTaggerSettings.getUIFile("matchselectionwindow.ui"), self)
 
-        self.altCoverWidget = CoverImageWidget(
-            self.altCoverContainer, CoverImageWidget.AltCoverMode, config.runtime_config.user_cache_dir, talker
-        )
+        self.altCoverWidget = CoverImageWidget(self.altCoverContainer, CoverImageWidget.AltCoverMode)
         gridlayout = QtWidgets.QGridLayout(self.altCoverContainer)
         gridlayout.addWidget(self.altCoverWidget)
         gridlayout.setContentsMargins(0, 0, 0, 0)
 
-        self.archiveCoverWidget = CoverImageWidget(self.archiveCoverContainer, CoverImageWidget.ArchiveMode, None, None)
+        self.archiveCoverWidget = CoverImageWidget(self.archiveCoverContainer, CoverImageWidget.ArchiveMode)
         gridlayout = QtWidgets.QGridLayout(self.archiveCoverContainer)
         gridlayout.addWidget(self.archiveCoverWidget)
         gridlayout.setContentsMargins(0, 0, 0, 0)
 
-        reduce_widget_font_size(self.twList)
-        reduce_widget_font_size(self.teDescription, 1)
+        reduceWidgetFontSize(self.twList)
+        reduceWidgetFontSize(self.teDescription, 1)
 
-        self.setWindowFlags(
-            QtCore.Qt.WindowType(
-                self.windowFlags()
-                | QtCore.Qt.WindowType.WindowSystemMenuHint
-                | QtCore.Qt.WindowType.WindowMaximizeButtonHint
-            )
-        )
+        self.setWindowFlags(self.windowFlags() | QtCore.Qt.WindowSystemMenuHint | QtCore.Qt.WindowMaximizeButtonHint)
 
-        self.skipButton = QtWidgets.QPushButton("Skip to Next")
-        self.buttonBox.addButton(self.skipButton, QtWidgets.QDialogButtonBox.ButtonRole.ActionRole)
-        self.buttonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Ok).setText("Accept and Write Tags")
+        self.skipButton = QtWidgets.QPushButton(self.tr("Skip to Next"))
+        self.buttonBox.addButton(self.skipButton, QtWidgets.QDialogButtonBox.ActionRole)
+        self.buttonBox.button(QtWidgets.QDialogButtonBox.Ok).setText("Accept and Write Tags")
 
         self.match_set_list = match_set_list
-        self._style = style
+        self.style = style
         self.fetch_func = fetch_func
 
         self.current_match_set_idx = 0
 
-        self.twList.currentItemChanged.connect(self.current_item_changed)
-        self.twList.cellDoubleClicked.connect(self.cell_double_clicked)
-        self.skipButton.clicked.connect(self.skip_to_next)
+        self.twList.currentItemChanged.connect(self.currentItemChanged)
+        self.twList.cellDoubleClicked.connect(self.cellDoubleClicked)
+        self.skipButton.clicked.connect(self.skipToNext)
 
-        self.update_data()
+        self.updateData()
+
+    def updateData(self):
 
-    def update_data(self) -> None:
         self.current_match_set = self.match_set_list[self.current_match_set_idx]
 
         if self.current_match_set_idx + 1 == len(self.match_set_list):
-            self.buttonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Cancel).setDisabled(True)
-            self.skipButton.setText("Skip")
+            self.buttonBox.button(QtWidgets.QDialogButtonBox.Cancel).setDisabled(True)
+            # self.buttonBox.button(QtWidgets.QDialogButtonBox.Ok).setText("Accept")
+            self.skipButton.setText(self.tr("Skip"))
 
-        self.set_cover_image()
-        self.populate_table()
+        self.setCoverImage()
+        self.populateTable()
         self.twList.resizeColumnsToContents()
         self.twList.selectRow(0)
 
         path = self.current_match_set.ca.path
         self.setWindowTitle(
-            "Select correct match or skip ({} of {}): {}".format(
-                self.current_match_set_idx + 1,
-                len(self.match_set_list),
-                os.path.split(path)[1],
-            )
+            "Select correct match or skip ({0} of {1}): {2}".format(self.current_match_set_idx + 1, len(self.match_set_list), os.path.split(path)[1])
         )
 
-    def populate_table(self) -> None:
-        if not self.current_match_set:
-            return
+    def populateTable(self):
 
-        self.twList.setRowCount(0)
+        while self.twList.rowCount() > 0:
+            self.twList.removeRow(0)
 
         self.twList.setSortingEnabled(False)
 
@@ -125,135 +97,130 @@ class AutoTagMatchWindow(QtWidgets.QDialog):
 
             item_text = match["series"]
             item = QtWidgets.QTableWidgetItem(item_text)
-            item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
-            item.setData(QtCore.Qt.ItemDataRole.UserRole, (match,))
-            item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
+            item.setData(QtCore.Qt.ToolTipRole, item_text)
+            item.setData(QtCore.Qt.UserRole, (match,))
+            item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
             self.twList.setItem(row, 0, item)
 
             if match["publisher"] is not None:
-                item_text = str(match["publisher"])
+                item_text = "{0}".format(match["publisher"])
             else:
                 item_text = "Unknown"
             item = QtWidgets.QTableWidgetItem(item_text)
-            item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
-            item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
+            item.setData(QtCore.Qt.ToolTipRole, item_text)
+            item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
             self.twList.setItem(row, 1, item)
 
             month_str = ""
             year_str = "????"
             if match["month"] is not None:
-                month_str = f"-{int(match['month']):02d}"
+                month_str = "-{0:02d}".format(int(match["month"]))
             if match["year"] is not None:
-                year_str = str(match["year"])
+                year_str = "{0}".format(match["year"])
 
             item_text = year_str + month_str
             item = QtWidgets.QTableWidgetItem(item_text)
-            item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
-            item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
+            item.setData(QtCore.Qt.ToolTipRole, item_text)
+            item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
             self.twList.setItem(row, 2, item)
 
             item_text = match["issue_title"]
             if item_text is None:
                 item_text = ""
             item = QtWidgets.QTableWidgetItem(item_text)
-            item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
-            item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
+            item.setData(QtCore.Qt.ToolTipRole, item_text)
+            item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
             self.twList.setItem(row, 3, item)
 
             row += 1
 
         self.twList.resizeColumnsToContents()
         self.twList.setSortingEnabled(True)
-        self.twList.sortItems(2, QtCore.Qt.SortOrder.AscendingOrder)
+        self.twList.sortItems(2, QtCore.Qt.AscendingOrder)
         self.twList.selectRow(0)
         self.twList.resizeColumnsToContents()
         self.twList.horizontalHeader().setStretchLastSection(True)
 
-    def cell_double_clicked(self, r: int, c: int) -> None:
+    def cellDoubleClicked(self, r, c):
         self.accept()
 
-    def current_item_changed(self, curr: QtCore.QModelIndex, prev: QtCore.QModelIndex) -> None:
-        if curr is None:
-            return None
-        if prev is not None and prev.row() == curr.row():
-            return None
+    def currentItemChanged(self, curr, prev):
 
-        self.altCoverWidget.set_issue_details(
-            self.current_match()["issue_id"],
-            [self.current_match()["image_url"], *self.current_match()["alt_image_urls"]],
-        )
-        if self.current_match()["description"] is None:
+        if curr is None:
+            return
+        if prev is not None and prev.row() == curr.row():
+            return
+
+        self.altCoverWidget.setIssueID(self.currentMatch()["issue_id"])
+        if self.currentMatch()["description"] is None:
             self.teDescription.setText("")
         else:
-            self.teDescription.setText(self.current_match()["description"])
+            self.teDescription.setText(self.currentMatch()["description"])
 
-    def set_cover_image(self) -> None:
+    def setCoverImage(self):
         ca = self.current_match_set.ca
-        self.archiveCoverWidget.set_archive(ca)
+        self.archiveCoverWidget.setArchive(ca)
 
-    def current_match(self) -> IssueResult:
+    def currentMatch(self):
         row = self.twList.currentRow()
-        match: IssueResult = self.twList.item(row, 0).data(QtCore.Qt.ItemDataRole.UserRole)[0]
+        match = self.twList.item(row, 0).data(QtCore.Qt.UserRole)[0]
         return match
 
-    def accept(self) -> None:
-        self.save_match()
+    def accept(self):
+
+        self.saveMatch()
         self.current_match_set_idx += 1
 
         if self.current_match_set_idx == len(self.match_set_list):
             # no more items
             QtWidgets.QDialog.accept(self)
         else:
-            self.update_data()
+            self.updateData()
 
-    def skip_to_next(self) -> None:
+    def skipToNext(self):
         self.current_match_set_idx += 1
 
         if self.current_match_set_idx == len(self.match_set_list):
             # no more items
             QtWidgets.QDialog.reject(self)
         else:
-            self.update_data()
+            self.updateData()
 
-    def reject(self) -> None:
+    def reject(self):
         reply = QtWidgets.QMessageBox.question(
             self,
-            "Cancel Matching",
-            "Are you sure you wish to cancel the matching process?",
-            QtWidgets.QMessageBox.StandardButton.Yes,
-            QtWidgets.QMessageBox.StandardButton.No,
+            self.tr("Cancel Matching"),
+            self.tr("Are you sure you wish to cancel the matching process?"),
+            QtWidgets.QMessageBox.Yes,
+            QtWidgets.QMessageBox.No,
         )
 
-        if reply == QtWidgets.QMessageBox.StandardButton.No:
+        if reply == QtWidgets.QMessageBox.No:
             return
 
         QtWidgets.QDialog.reject(self)
 
-    def save_match(self) -> None:
-        match = self.current_match()
+    def saveMatch(self):
+
+        match = self.currentMatch()
         ca = self.current_match_set.ca
 
-        md = ca.read_metadata(self._style)
-        if md.is_empty:
-            md = ca.metadata_from_filename(
-                self.config.filename_complicated_parser,
-                self.config.filename_remove_c2c,
-                self.config.filename_remove_fcbd,
-                self.config.filename_remove_publisher,
-            )
+        md = ca.readMetadata(self.style)
+        if md.isEmpty:
+            md = ca.metadataFromFilename()
 
         # now get the particular issue data
-        ct_md = self.fetch_func(match)
-        if ct_md is None:
-            QtWidgets.QMessageBox.critical(self, "Network Issue", "Could not retrieve issue details!")
+        cv_md = self.fetch_func(match)
+        if cv_md is None:
+            QtWidgets.QMessageBox.critical(self, self.tr("Network Issue"), self.tr("Could not connect to Comic Vine to get issue details!"))
             return
 
-        QtWidgets.QApplication.setOverrideCursor(QtGui.QCursor(QtCore.Qt.CursorShape.WaitCursor))
-        md.overlay(ct_md)
-        success = ca.write_metadata(md, self._style)
-        ca.load_cache([MetaDataStyle.CBI, MetaDataStyle.CIX])
+        QtWidgets.QApplication.setOverrideCursor(QtGui.QCursor(QtCore.Qt.WaitCursor))
+        md.overlay(cv_md)
+        success = ca.writeMetadata(md, self.style)
+        ca.loadCache([MetaDataStyle.CBI, MetaDataStyle.CIX])
 
         QtWidgets.QApplication.restoreOverrideCursor()
 
         if not success:
-            QtWidgets.QMessageBox.warning(self, "Write Error", "Saving the tags to the archive seemed to fail!")
+            QtWidgets.QMessageBox.warning(self, self.tr("Write Error"), self.tr("Saving the tags to the archive seemed to fail!"))

comictaggerlib/autotagprogresswindow.py

@@ -1,73 +1,60 @@
 """A PyQT4 dialog to show ID log and progress"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import logging
+from PyQt5 import QtCore, QtGui, QtWidgets, uic
 
-from PyQt5 import QtCore, QtWidgets, uic
+from comictaggerlib.ui.qtutils import reduceWidgetFontSize
 
-from comictaggerlib.coverimagewidget import CoverImageWidget
-from comictaggerlib.ui import ui_path
-from comictaggerlib.ui.qtutils import reduce_widget_font_size
-from comictalker.comictalker import ComicTalker
-
-logger = logging.getLogger(__name__)
+from .coverimagewidget import CoverImageWidget
+from .settings import ComicTaggerSettings
 
 
 class AutoTagProgressWindow(QtWidgets.QDialog):
-    def __init__(self, parent: QtWidgets.QWidget, talker: ComicTalker) -> None:
-        super().__init__(parent)
+    def __init__(self, parent):
+        super(AutoTagProgressWindow, self).__init__(parent)
 
-        uic.loadUi(ui_path / "autotagprogresswindow.ui", self)
+        uic.loadUi(ComicTaggerSettings.getUIFile("autotagprogresswindow.ui"), self)
 
-        self.archiveCoverWidget = CoverImageWidget(
-            self.archiveCoverContainer, CoverImageWidget.DataMode, None, None, False
-        )
+        self.archiveCoverWidget = CoverImageWidget(self.archiveCoverContainer, CoverImageWidget.DataMode, False)
         gridlayout = QtWidgets.QGridLayout(self.archiveCoverContainer)
         gridlayout.addWidget(self.archiveCoverWidget)
         gridlayout.setContentsMargins(0, 0, 0, 0)
 
-        self.testCoverWidget = CoverImageWidget(self.testCoverContainer, CoverImageWidget.DataMode, None, None, False)
+        self.testCoverWidget = CoverImageWidget(self.testCoverContainer, CoverImageWidget.DataMode, False)
         gridlayout = QtWidgets.QGridLayout(self.testCoverContainer)
         gridlayout.addWidget(self.testCoverWidget)
         gridlayout.setContentsMargins(0, 0, 0, 0)
 
         self.isdone = False
 
-        self.setWindowFlags(
-            QtCore.Qt.WindowType(
-                self.windowFlags()
-                | QtCore.Qt.WindowType.WindowSystemMenuHint
-                | QtCore.Qt.WindowType.WindowMaximizeButtonHint
-            )
-        )
+        self.setWindowFlags(self.windowFlags() | QtCore.Qt.WindowSystemMenuHint | QtCore.Qt.WindowMaximizeButtonHint)
 
-        reduce_widget_font_size(self.textEdit)
+        reduceWidgetFontSize(self.textEdit)
 
-    def set_archive_image(self, img_data: bytes) -> None:
-        self.set_cover_image(img_data, self.archiveCoverWidget)
+    def setArchiveImage(self, img_data):
+        self.setCoverImage(img_data, self.archiveCoverWidget)
 
-    def set_test_image(self, img_data: bytes) -> None:
-        self.set_cover_image(img_data, self.testCoverWidget)
+    def setTestImage(self, img_data):
+        self.setCoverImage(img_data, self.testCoverWidget)
 
-    def set_cover_image(self, img_data: bytes, widget: CoverImageWidget) -> None:
-        widget.set_image_data(img_data)
+    def setCoverImage(self, img_data, widget):
+        widget.setImageData(img_data)
         QtCore.QCoreApplication.processEvents()
         QtCore.QCoreApplication.processEvents()
 
-    def reject(self) -> None:
+    def reject(self):
         QtWidgets.QDialog.reject(self)
         self.isdone = True

comictaggerlib/autotagstartwindow.py

@@ -1,106 +1,114 @@
-"""A PyQT4 dialog to confirm and set config for auto-tag"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+"""A PyQT4 dialog to confirm and set options for auto-tag"""
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import logging
+from PyQt5 import QtCore, QtGui, QtWidgets, uic
 
-import settngs
-from PyQt5 import QtCore, QtWidgets, uic
-
-from comictaggerlib.ui import ui_path
-
-logger = logging.getLogger(__name__)
+from .settings import ComicTaggerSettings
 
 
 class AutoTagStartWindow(QtWidgets.QDialog):
-    def __init__(self, parent: QtWidgets.QWidget, config: settngs.Namespace, msg: str) -> None:
-        super().__init__(parent)
+    def __init__(self, parent, settings, msg):
+        super(AutoTagStartWindow, self).__init__(parent)
 
-        uic.loadUi(ui_path / "autotagstartwindow.ui", self)
+        uic.loadUi(ComicTaggerSettings.getUIFile("autotagstartwindow.ui"), self)
         self.label.setText(msg)
 
-        self.setWindowFlags(
-            QtCore.Qt.WindowType(self.windowFlags() & ~QtCore.Qt.WindowType.WindowContextHelpButtonHint)
-        )
+        self.setWindowFlags(self.windowFlags() & ~QtCore.Qt.WindowContextHelpButtonHint)
 
-        self.config = config
+        self.settings = settings
 
-        self.cbxSpecifySearchString.setChecked(False)
-        self.cbxSplitWords.setChecked(False)
-        self.sbNameMatchSearchThresh.setValue(self.config.identifier_series_match_identify_thresh)
+        self.cbxSaveOnLowConfidence.setCheckState(QtCore.Qt.Unchecked)
+        self.cbxDontUseYear.setCheckState(QtCore.Qt.Unchecked)
+        self.cbxAssumeIssueOne.setCheckState(QtCore.Qt.Unchecked)
+        self.cbxIgnoreLeadingDigitsInFilename.setCheckState(QtCore.Qt.Unchecked)
+        self.cbxRemoveAfterSuccess.setCheckState(QtCore.Qt.Unchecked)
+        self.cbxSpecifySearchString.setCheckState(QtCore.Qt.Unchecked)
+        self.cbxAutoImprint.setCheckState(QtCore.Qt.Unchecked)
+        self.leNameLengthMatchTolerance.setText(str(self.settings.id_length_delta_thresh))
         self.leSearchString.setEnabled(False)
 
-        self.cbxSaveOnLowConfidence.setChecked(self.config.autotag_save_on_low_confidence)
-        self.cbxDontUseYear.setChecked(self.config.autotag_dont_use_year_when_identifying)
-        self.cbxAssumeIssueOne.setChecked(self.config.autotag_assume_1_if_no_issue_num)
-        self.cbxIgnoreLeadingDigitsInFilename.setChecked(self.config.autotag_ignore_leading_numbers_in_filename)
-        self.cbxRemoveAfterSuccess.setChecked(self.config.autotag_remove_archive_after_successful_match)
-        self.cbxWaitForRateLimit.setChecked(self.config.autotag_wait_and_retry_on_rate_limit)
-        self.cbxAutoImprint.setChecked(self.config.identifier_auto_imprint)
+        if self.settings.save_on_low_confidence:
+            self.cbxSaveOnLowConfidence.setCheckState(QtCore.Qt.Checked)
+        if self.settings.dont_use_year_when_identifying:
+            self.cbxDontUseYear.setCheckState(QtCore.Qt.Checked)
+        if self.settings.assume_1_if_no_issue_num:
+            self.cbxAssumeIssueOne.setCheckState(QtCore.Qt.Checked)
+        if self.settings.ignore_leading_numbers_in_filename:
+            self.cbxIgnoreLeadingDigitsInFilename.setCheckState(QtCore.Qt.Checked)
+        if self.settings.remove_archive_after_successful_match:
+            self.cbxRemoveAfterSuccess.setCheckState(QtCore.Qt.Checked)
+        if self.settings.wait_and_retry_on_rate_limit:
+            self.cbxWaitForRateLimit.setCheckState(QtCore.Qt.Checked)
+        if self.settings.auto_imprint:
+            self.cbxAutoImprint.setCheckState(QtCore.Qt.Checked)
 
-        nlmt_tip = """<html>The <b>Name Match Ratio Threshold: Auto-Identify</b> is for eliminating automatic
-                search matches that are too long compared to your series name search. The lower
+        nlmtTip = """ <html>The <b>Name Length Match Tolerance</b> is for eliminating automatic
+                search matches that are too long compared to your series name search. The higher
                 it is, the more likely to have a good match, but each search will take longer and
-                use more bandwidth. Too high, and only the very closest matches will be explored.</html>"""
+                use more bandwidth. Too low, and only the very closest lexical matches will be
+                explored.</html>"""
 
-        self.sbNameMatchSearchThresh.setToolTip(nlmt_tip)
+        self.leNameLengthMatchTolerance.setToolTip(nlmtTip)
 
-        ss_tip = """<html>
+        ssTip = """<html>
             The <b>series search string</b> specifies the search string to be used for all selected archives.
             Use this when trying to match archives with hard-to-parse or incorrect filenames.  All archives selected
             should be from the same series.
             </html>"""
-        self.leSearchString.setToolTip(ss_tip)
-        self.cbxSpecifySearchString.setToolTip(ss_tip)
+        self.leSearchString.setToolTip(ssTip)
+        self.cbxSpecifySearchString.setToolTip(ssTip)
 
-        self.cbxSpecifySearchString.stateChanged.connect(self.search_string_toggle)
+        validator = QtGui.QIntValidator(0, 99, self)
+        self.leNameLengthMatchTolerance.setValidator(validator)
 
-        self.auto_save_on_low = False
-        self.dont_use_year = False
-        self.assume_issue_one = False
-        self.ignore_leading_digits_in_filename = False
-        self.remove_after_success = False
-        self.wait_and_retry_on_rate_limit = False
-        self.search_string = ""
-        self.name_length_match_tolerance = self.config.identifier_series_match_search_thresh
-        self.split_words = self.cbxSplitWords.isChecked()
+        self.cbxSpecifySearchString.stateChanged.connect(self.searchStringToggle)
 
-    def search_string_toggle(self) -> None:
+        self.autoSaveOnLow = False
+        self.dontUseYear = False
+        self.assumeIssueOne = False
+        self.ignoreLeadingDigitsInFilename = False
+        self.removeAfterSuccess = False
+        self.waitAndRetryOnRateLimit = False
+        self.searchString = None
+        self.nameLengthMatchTolerance = self.settings.id_length_delta_thresh
+
+    def searchStringToggle(self):
         enable = self.cbxSpecifySearchString.isChecked()
         self.leSearchString.setEnabled(enable)
 
-    def accept(self) -> None:
+    def accept(self):
         QtWidgets.QDialog.accept(self)
 
-        self.auto_save_on_low = self.cbxSaveOnLowConfidence.isChecked()
-        self.dont_use_year = self.cbxDontUseYear.isChecked()
-        self.assume_issue_one = self.cbxAssumeIssueOne.isChecked()
-        self.ignore_leading_digits_in_filename = self.cbxIgnoreLeadingDigitsInFilename.isChecked()
-        self.remove_after_success = self.cbxRemoveAfterSuccess.isChecked()
-        self.name_length_match_tolerance = self.sbNameMatchSearchThresh.value()
-        self.wait_and_retry_on_rate_limit = self.cbxWaitForRateLimit.isChecked()
-        self.split_words = self.cbxSplitWords.isChecked()
+        self.autoSaveOnLow = self.cbxSaveOnLowConfidence.isChecked()
+        self.dontUseYear = self.cbxDontUseYear.isChecked()
+        self.assumeIssueOne = self.cbxAssumeIssueOne.isChecked()
+        self.ignoreLeadingDigitsInFilename = self.cbxIgnoreLeadingDigitsInFilename.isChecked()
+        self.removeAfterSuccess = self.cbxRemoveAfterSuccess.isChecked()
+        self.nameLengthMatchTolerance = int(self.leNameLengthMatchTolerance.text())
+        self.waitAndRetryOnRateLimit = self.cbxWaitForRateLimit.isChecked()
 
         # persist some settings
-        self.config.autotag_save_on_low_confidence = self.auto_save_on_low
-        self.config.autotag_dont_use_year_when_identifying = self.dont_use_year
-        self.config.autotag_assume_1_if_no_issue_num = self.assume_issue_one
-        self.config.autotag_ignore_leading_numbers_in_filename = self.ignore_leading_digits_in_filename
-        self.config.autotag_remove_archive_after_successful_match = self.remove_after_success
-        self.config.autotag_wait_and_retry_on_rate_limit = self.wait_and_retry_on_rate_limit
+        self.settings.save_on_low_confidence = self.autoSaveOnLow
+        self.settings.dont_use_year_when_identifying = self.dontUseYear
+        self.settings.assume_1_if_no_issue_num = self.assumeIssueOne
+        self.settings.ignore_leading_numbers_in_filename = self.ignoreLeadingDigitsInFilename
+        self.settings.remove_archive_after_successful_match = self.removeAfterSuccess
+        self.settings.wait_and_retry_on_rate_limit = self.waitAndRetryOnRateLimit
 
         if self.cbxSpecifySearchString.isChecked():
-            self.search_string = self.leSearchString.text()
+            self.searchString = str(self.leSearchString.text())
+            if len(self.searchString) == 0:
+                self.searchString = None

comictaggerlib/cbltransformer.py

@@ -1,53 +1,46 @@
 """A class to manage modifying metadata specifically for CBL/CBI"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import logging
-
-import settngs
-
-from comicapi.genericmetadata import CreditMetadata, GenericMetadata
-
-logger = logging.getLogger(__name__)
 
 
 class CBLTransformer:
-    def __init__(self, metadata: GenericMetadata, config: settngs.Namespace) -> None:
+    def __init__(self, metadata, settings):
         self.metadata = metadata
-        self.config = config
+        self.settings = settings
 
-    def apply(self) -> GenericMetadata:
+    def apply(self):
         # helper funcs
-        def append_to_tags_if_unique(item: str) -> None:
-            if item.casefold() not in (tag.casefold() for tag in self.metadata.tags):
-                self.metadata.tags.add(item)
+        def append_to_tags_if_unique(item):
+            if item.lower() not in (tag.lower() for tag in self.metadata.tags):
+                self.metadata.tags.append(item)
 
-        def add_string_list_to_tags(str_list: str | None) -> None:
-            if str_list:
+        def add_string_list_to_tags(str_list):
+            if str_list is not None and str_list != "":
                 items = [s.strip() for s in str_list.split(",")]
                 for item in items:
                     append_to_tags_if_unique(item)
 
-        if self.config.cbl_assume_lone_credit_is_primary:
+        if self.settings.assume_lone_credit_is_primary:
+
             # helper
-            def set_lone_primary(role_list: list[str]) -> tuple[CreditMetadata | None, int]:
-                lone_credit: CreditMetadata | None = None
+            def setLonePrimary(role_list):
+                lone_credit = None
                 count = 0
                 for c in self.metadata.credits:
-                    if c["role"].casefold() in role_list:
+                    if c["role"].lower() in role_list:
                         count += 1
                         lone_credit = c
                     if count > 1:
@@ -59,27 +52,27 @@ class CBLTransformer:
 
             # need to loop three times, once for 'writer', 'artist', and then
             # 'penciler' if no artist
-            set_lone_primary(["writer"])
-            c, count = set_lone_primary(["artist"])
+            setLonePrimary(["writer"])
+            c, count = setLonePrimary(["artist"])
             if c is None and count == 0:
-                c, count = set_lone_primary(["penciler", "penciller"])
+                c, count = setLonePrimary(["penciler", "penciller"])
                 if c is not None:
                     c["primary"] = False
-                    self.metadata.add_credit(c["person"], "Artist", True)
+                    self.metadata.addCredit(c["person"], "Artist", True)
 
-        if self.config.cbl_copy_characters_to_tags:
+        if self.settings.copy_characters_to_tags:
             add_string_list_to_tags(self.metadata.characters)
 
-        if self.config.cbl_copy_teams_to_tags:
+        if self.settings.copy_teams_to_tags:
             add_string_list_to_tags(self.metadata.teams)
 
-        if self.config.cbl_copy_locations_to_tags:
+        if self.settings.copy_locations_to_tags:
             add_string_list_to_tags(self.metadata.locations)
 
-        if self.config.cbl_copy_storyarcs_to_tags:
-            add_string_list_to_tags(self.metadata.story_arc)
+        if self.settings.copy_storyarcs_to_tags:
+            add_string_list_to_tags(self.metadata.storyArc)
 
-        if self.config.cbl_copy_notes_to_comments:
+        if self.settings.copy_notes_to_comments:
             if self.metadata.notes is not None:
                 if self.metadata.comments is None:
                     self.metadata.comments = ""
@@ -88,13 +81,13 @@ class CBLTransformer:
                 if self.metadata.notes not in self.metadata.comments:
                     self.metadata.comments += self.metadata.notes
 
-        if self.config.cbl_copy_weblink_to_comments:
-            if self.metadata.web_link is not None:
+        if self.settings.copy_weblink_to_comments:
+            if self.metadata.webLink is not None:
                 if self.metadata.comments is None:
                     self.metadata.comments = ""
                 else:
                     self.metadata.comments += "\n\n"
-                if self.metadata.web_link not in self.metadata.comments:
-                    self.metadata.comments += self.metadata.web_link
+                if self.metadata.webLink not in self.metadata.comments:
+                    self.metadata.comments += self.metadata.webLink
 
         return self.metadata

comictaggerlib/cli.py

@@ -1,383 +1,384 @@
 #!/usr/bin/python
+
 """ComicTagger CLI functions"""
-#
-# Copyright 2013 ComicTagger Authors
-#
+
+# Copyright 2013 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
 import json
-import logging
 import os
 import sys
-from datetime import datetime
 from pprint import pprint
 
-import settngs
+from . import utils
+from .cbltransformer import CBLTransformer
+from .comicarchive import ComicArchive, MetaDataStyle
+from .comicvinetalker import ComicVineTalker, ComicVineTalkerException
+from .filerenamer import FileRenamer
+from .genericmetadata import GenericMetadata
+from .issueidentifier import IssueIdentifier
+from .options import Options
+from .settings import ComicTaggerSettings
 
-from comicapi import utils
-from comicapi.comicarchive import ComicArchive, MetaDataStyle
-from comicapi.genericmetadata import GenericMetadata
-from comictaggerlib import ctversion
-from comictaggerlib.cbltransformer import CBLTransformer
-from comictaggerlib.filerenamer import FileRenamer, get_rename_dir
-from comictaggerlib.graphics import graphics_path
-from comictaggerlib.issueidentifier import IssueIdentifier
-from comictaggerlib.resulttypes import MultipleMatch, OnlineMatchResults
-from comictalker.comictalker import ComicTalker, TalkerError
-
-logger = logging.getLogger(__name__)
+filename_encoding = sys.getfilesystemencoding()
 
 
-class CLI:
-    def __init__(self, config: settngs.Namespace, talkers: dict[str, ComicTalker]):
-        self.config = config
-        self.talkers = talkers
-        self.batch_mode = False
+class MultipleMatch:
+    def __init__(self, filename, match_list):
+        self.filename = filename
+        self.matches = match_list
 
-    def current_talker(self) -> ComicTalker:
-        if self.config[0].talker_source in self.talkers:
-            return self.talkers[self.config[0].talker_source]
-        logger.error("Could not find the '%s' talker", self.config[0].talker_source)
-        raise SystemExit(2)
 
-    def actual_issue_data_fetch(self, issue_id: str) -> GenericMetadata:
-        # now get the particular issue data
-        try:
-            ct_md = self.current_talker().fetch_comic_data(issue_id)
-        except TalkerError as e:
-            logger.exception(f"Error retrieving issue details. Save aborted.\n{e}")
-            return GenericMetadata()
+class OnlineMatchResults:
+    def __init__(self):
+        self.goodMatches = []
+        self.noMatches = []
+        self.multipleMatches = []
+        self.lowConfidenceMatches = []
+        self.writeFailures = []
+        self.fetchDataFailures = []
 
-        if self.config.cbl_apply_transform_on_import:
-            ct_md = CBLTransformer(ct_md, self.config).apply()
 
-        return ct_md
+def actual_issue_data_fetch(match, settings, opts):
 
-    def actual_metadata_save(self, ca: ComicArchive, md: GenericMetadata) -> bool:
-        if not self.config.runtime_dryrun:
-            for metadata_style in self.config.runtime_type:
-                # write out the new data
-                if not ca.write_metadata(md, metadata_style):
-                    logger.error("The tag save seemed to fail for style: %s!", MetaDataStyle.name[metadata_style])
-                    return False
+    # now get the particular issue data
+    try:
+        comicVine = ComicVineTalker()
+        comicVine.wait_for_rate_limit = opts.wait_and_retry_on_rate_limit
+        cv_md = comicVine.fetchIssueData(match["volume_id"], match["issue_number"], settings)
+    except ComicVineTalkerException:
+        print("Network error while getting issue details.  Save aborted", file=sys.stderr)
+        return None
 
-            print("Save complete.")
-            logger.info("Save complete.")
+    if settings.apply_cbl_transform_on_cv_import:
+        cv_md = CBLTransformer(cv_md, settings).apply()
+
+    return cv_md
+
+
+def actual_metadata_save(ca, opts, md):
+
+    if not opts.dryrun:
+        # write out the new data
+        if not ca.writeMetadata(md, opts.data_style):
+            print("The tag save seemed to fail!", file=sys.stderr)
+            return False
         else:
-            if self.config.runtime_quiet:
-                logger.info("dry-run option was set, so nothing was written")
-                print("dry-run option was set, so nothing was written")
+            print("Save complete.", file=sys.stderr)
+    else:
+        if opts.terse:
+            print("dry-run option was set, so nothing was written", file=sys.stderr)
+        else:
+            print("dry-run option was set, so nothing was written, but here is the final set of tags:", file=sys.stderr)
+            print("{0}".format(md))
+    return True
+
+
+def display_match_set_for_choice(label, match_set, opts, settings):
+    print("{0} -- {1}:".format(match_set.filename, label))
+
+    # sort match list by year
+    match_set.matches.sort(key=lambda k: k["year"])
+
+    for (counter, m) in enumerate(match_set.matches):
+        counter += 1
+        print(
+            "    {0}. {1} #{2} [{3}] ({4}/{5}) - {6}".format(
+                counter, m["series"], m["issue_number"], m["publisher"], m["month"], m["year"], m["issue_title"]
+            )
+        )
+    if opts.interactive:
+        while True:
+            i = input("Choose a match #, or 's' to skip: ")
+            if (i.isdigit() and int(i) in range(1, len(match_set.matches) + 1)) or i == "s":
+                break
+        if i != "s":
+            i = int(i) - 1
+            # save the data!
+            # we know at this point, that the file is all good to go
+            ca = ComicArchive(match_set.filename, settings.rar_exe_path, ComicTaggerSettings.getGraphic("nocover.png"))
+            md = create_local_metadata(opts, ca, ca.hasMetadata(opts.data_style))
+            cv_md = actual_issue_data_fetch(match_set.matches[int(i)], settings, opts)
+            md.overlay(cv_md)
+
+            if settings.auto_imprint:
+                md.fixPublisher()
+
+            actual_metadata_save(ca, opts, md)
+
+
+def post_process_matches(match_results, opts, settings):
+    # now go through the match results
+    if opts.show_save_summary:
+        if len(match_results.goodMatches) > 0:
+            print("\nSuccessful matches:\n------------------")
+            for f in match_results.goodMatches:
+                print(f)
+
+        if len(match_results.noMatches) > 0:
+            print("\nNo matches:\n------------------")
+            for f in match_results.noMatches:
+                print(f)
+
+        if len(match_results.writeFailures) > 0:
+            print("\nFile Write Failures:\n------------------")
+            for f in match_results.writeFailures:
+                print(f)
+
+        if len(match_results.fetchDataFailures) > 0:
+            print("\nNetwork Data Fetch Failures:\n------------------")
+            for f in match_results.fetchDataFailures:
+                print(f)
+
+    if not opts.show_save_summary and not opts.interactive:
+        # just quit if we're not interactive or showing the summary
+        return
+
+    if len(match_results.multipleMatches) > 0:
+        print("\nArchives with multiple high-confidence matches:\n------------------")
+        for match_set in match_results.multipleMatches:
+            display_match_set_for_choice("Multiple high-confidence matches", match_set, opts, settings)
+
+    if len(match_results.lowConfidenceMatches) > 0:
+        print("\nArchives with low-confidence matches:\n------------------")
+        for match_set in match_results.lowConfidenceMatches:
+            if len(match_set.matches) == 1:
+                label = "Single low-confidence match"
             else:
-                logger.info("dry-run option was set, so nothing was written, but here is the final set of tags:")
-                print("dry-run option was set, so nothing was written, but here is the final set of tags:")
-                print(f"{md}")
-        return True
+                label = "Multiple low-confidence matches"
 
-    def display_match_set_for_choice(self, label: str, match_set: MultipleMatch) -> None:
-        print(f"{match_set.ca.path} -- {label}:")
+            display_match_set_for_choice(label, match_set, opts, settings)
 
-        # sort match list by year
-        match_set.matches.sort(key=lambda k: k["year"] or 0)
 
-        for counter, m in enumerate(match_set.matches):
-            counter += 1
-            print(
-                "    {}. {} #{} [{}] ({}/{}) - {}".format(
-                    counter,
-                    m["series"],
-                    m["issue_number"],
-                    m["publisher"],
-                    m["month"],
-                    m["year"],
-                    m["issue_title"],
-                )
-            )
-        if self.config.runtime_interactive:
-            while True:
-                i = input("Choose a match #, or 's' to skip: ")
-                if (i.isdigit() and int(i) in range(1, len(match_set.matches) + 1)) or i == "s":
-                    break
-            if i != "s":
-                # save the data!
-                # we know at this point, that the file is all good to go
-                ca = match_set.ca
-                md = self.create_local_metadata(ca)
-                ct_md = self.actual_issue_data_fetch(match_set.matches[int(i) - 1]["issue_id"])
-                if self.config.identifier_clear_metadata_on_import:
-                    md = ct_md
-                else:
-                    notes = (
-                        f"Tagged with ComicTagger {ctversion.version} using info from Comic Vine on"
-                        f" {datetime.now():%Y-%m-%d %H:%M:%S}.  [Issue ID {ct_md.issue_id}]"
-                    )
-                    md.overlay(ct_md.replace(notes=utils.combine_notes(md.notes, notes, "Tagged with ComicTagger")))
+def cli_mode(opts, settings):
+    if len(opts.file_list) < 1:
+        print("You must specify at least one filename.  Use the -h option for more info", file=sys.stderr)
+        return
 
-                if self.config.identifier_auto_imprint:
-                    md.fix_publisher()
+    match_results = OnlineMatchResults()
 
-                self.actual_metadata_save(ca, md)
+    for f in opts.file_list:
+        if isinstance(f, str):
+            pass
+        process_file_cli(f, opts, settings, match_results)
+        sys.stdout.flush()
 
-    def post_process_matches(self, match_results: OnlineMatchResults) -> None:
-        # now go through the match results
-        if self.config.runtime_summary:
-            if len(match_results.good_matches) > 0:
-                print("\nSuccessful matches:\n------------------")
-                for f in match_results.good_matches:
-                    print(f)
+    post_process_matches(match_results, opts, settings)
 
-            if len(match_results.no_matches) > 0:
-                print("\nNo matches:\n------------------")
-                for f in match_results.no_matches:
-                    print(f)
 
-            if len(match_results.write_failures) > 0:
-                print("\nFile Write Failures:\n------------------")
-                for f in match_results.write_failures:
-                    print(f)
+def create_local_metadata(opts, ca, has_desired_tags):
 
-            if len(match_results.fetch_data_failures) > 0:
-                print("\nNetwork Data Fetch Failures:\n------------------")
-                for f in match_results.fetch_data_failures:
-                    print(f)
+    md = GenericMetadata()
+    md.setDefaultPageList(ca.getNumberOfPages())
 
-        if not self.config.runtime_summary and not self.config.runtime_interactive:
-            # just quit if we're not interactive or showing the summary
-            return
+    if has_desired_tags:
+        md = ca.readMetadata(opts.data_style)
 
-        if len(match_results.multiple_matches) > 0:
-            print("\nArchives with multiple high-confidence matches:\n------------------")
-            for match_set in match_results.multiple_matches:
-                self.display_match_set_for_choice("Multiple high-confidence matches", match_set)
+    # now, overlay the parsed filename info
+    if opts.parse_filename:
+        md.overlay(ca.metadataFromFilename())
 
-        if len(match_results.low_confidence_matches) > 0:
-            print("\nArchives with low-confidence matches:\n------------------")
-            for match_set in match_results.low_confidence_matches:
-                if len(match_set.matches) == 1:
-                    label = "Single low-confidence match"
-                else:
-                    label = "Multiple low-confidence matches"
+    # finally, use explicit stuff
+    if opts.metadata is not None:
+        md.overlay(opts.metadata)
 
-                self.display_match_set_for_choice(label, match_set)
+    return md
 
-    def run(self) -> None:
-        if len(self.config.runtime_file_list) < 1:
-            logger.error("You must specify at least one filename.  Use the -h option for more info")
-            return
 
-        match_results = OnlineMatchResults()
-        self.batch_mode = len(self.config.runtime_file_list) > 1
+def process_file_cli(filename, opts, settings, match_results):
 
-        for f in self.config.runtime_file_list:
-            self.process_file_cli(f, match_results)
-            sys.stdout.flush()
+    batch_mode = len(opts.file_list) > 1
 
-        self.post_process_matches(match_results)
+    settings.auto_imprint = opts.auto_imprint
 
-    def create_local_metadata(self, ca: ComicArchive) -> GenericMetadata:
-        md = GenericMetadata()
-        md.set_default_page_list(ca.get_number_of_pages())
+    ca = ComicArchive(filename, settings.rar_exe_path, ComicTaggerSettings.getGraphic("nocover.png"))
 
-        # now, overlay the parsed filename info
-        if self.config.runtime_parse_filename:
-            f_md = ca.metadata_from_filename(
-                self.config.filename_complicated_parser,
-                self.config.filename_remove_c2c,
-                self.config.filename_remove_fcbd,
-                self.config.filename_remove_publisher,
-                self.config.runtime_split_words,
-            )
+    if not os.path.lexists(filename):
+        print("Cannot find " + filename, file=sys.stderr)
+        return
 
-            md.overlay(f_md)
+    if not ca.seemsToBeAComicArchive():
+        print("Sorry, but " + filename + "  is not a comic archive!", file=sys.stderr)
+        return
 
-        for metadata_style in self.config.runtime_type:
-            if ca.has_metadata(metadata_style):
-                try:
-                    t_md = ca.read_metadata(metadata_style)
-                    md.overlay(t_md)
-                    break
-                except Exception as e:
-                    logger.error("Failed to load metadata for %s: %s", ca.path, e)
+    # if not ca.isWritableForStyle(opts.data_style) and (opts.delete_tags or
+    # opts.save_tags or opts.rename_file):
+    if not ca.isWritable() and (opts.delete_tags or opts.copy_tags or opts.save_tags or opts.rename_file):
+        print("This archive is not writable for that tag type", file=sys.stderr)
+        return
 
-        # finally, use explicit stuff
-        md.overlay(self.config.runtime_metadata)
+    has = [False, False, False]
+    if ca.hasCIX():
+        has[MetaDataStyle.CIX] = True
+    if ca.hasCBI():
+        has[MetaDataStyle.CBI] = True
+    if ca.hasCoMet():
+        has[MetaDataStyle.COMET] = True
 
-        return md
+    if opts.print_tags:
 
-    def print(self, ca: ComicArchive) -> None:
-        if not self.config.runtime_type:
-            page_count = ca.get_number_of_pages()
+        if opts.data_style is None:
+            page_count = ca.getNumberOfPages()
 
             brief = ""
 
-            if self.batch_mode:
-                brief = f"{ca.path}: "
+            if batch_mode:
+                brief = "{0}: ".format(filename)
 
-            brief += ca.archiver.name() + " archive "
+            if ca.isZip():
+                brief += "ZIP archive    "
+            elif ca.isRar():
+                brief += "RAR archive    "
+            elif ca.isFolder():
+                brief += "Folder archive "
 
-            brief += f"({page_count: >3} pages)"
+            brief += "({0: >3} pages)".format(page_count)
             brief += "  tags:[ "
 
-            if not (
-                ca.has_metadata(MetaDataStyle.CBI)
-                or ca.has_metadata(MetaDataStyle.CIX)
-                or ca.has_metadata(MetaDataStyle.COMET)
-            ):
+            if not (has[MetaDataStyle.CBI] or has[MetaDataStyle.CIX] or has[MetaDataStyle.COMET]):
                 brief += "none "
             else:
-                if ca.has_metadata(MetaDataStyle.CBI):
+                if has[MetaDataStyle.CBI]:
                     brief += "CBL "
-                if ca.has_metadata(MetaDataStyle.CIX):
+                if has[MetaDataStyle.CIX]:
                     brief += "CR "
-                if ca.has_metadata(MetaDataStyle.COMET):
+                if has[MetaDataStyle.COMET]:
                     brief += "CoMet "
             brief += "]"
 
             print(brief)
 
-        if self.config.runtime_quiet:
+        if opts.terse:
             return
 
         print()
 
-        if not self.config.runtime_type or MetaDataStyle.CIX in self.config.runtime_type:
-            if ca.has_metadata(MetaDataStyle.CIX):
+        if opts.data_style is None or opts.data_style == MetaDataStyle.CIX:
+            if has[MetaDataStyle.CIX]:
                 print("--------- ComicRack tags ---------")
-                try:
-                    if self.config.runtime_raw:
-                        print(ca.read_raw_cix())
-                    else:
-                        print(ca.read_cix())
-                except Exception as e:
-                    logger.error("Failed to load metadata for %s: %s", ca.path, e)
+                if opts.raw:
+                    print("{0}".format(str(ca.readRawCIX(), errors="ignore")))
+                else:
+                    print("{0}".format(ca.readCIX()))
 
-        if not self.config.runtime_type or MetaDataStyle.CBI in self.config.runtime_type:
-            if ca.has_metadata(MetaDataStyle.CBI):
+        if opts.data_style is None or opts.data_style == MetaDataStyle.CBI:
+            if has[MetaDataStyle.CBI]:
                 print("------- ComicBookLover tags -------")
-                try:
-                    if self.config.runtime_raw:
-                        pprint(json.loads(ca.read_raw_cbi()))
-                    else:
-                        print(ca.read_cbi())
-                except Exception as e:
-                    logger.error("Failed to load metadata for %s: %s", ca.path, e)
+                if opts.raw:
+                    pprint(json.loads(ca.readRawCBI()))
+                else:
+                    print("{0}".format(ca.readCBI()))
 
-        if not self.config.runtime_type or MetaDataStyle.COMET in self.config.runtime_type:
-            if ca.has_metadata(MetaDataStyle.COMET):
+        if opts.data_style is None or opts.data_style == MetaDataStyle.COMET:
+            if has[MetaDataStyle.COMET]:
                 print("----------- CoMet tags -----------")
-                try:
-                    if self.config.runtime_raw:
-                        print(ca.read_raw_comet())
-                    else:
-                        print(ca.read_comet())
-                except Exception as e:
-                    logger.error("Failed to load metadata for %s: %s", ca.path, e)
-
-    def delete(self, ca: ComicArchive) -> None:
-        for metadata_style in self.config.runtime_type:
-            style_name = MetaDataStyle.name[metadata_style]
-            if ca.has_metadata(metadata_style):
-                if not self.config.runtime_dryrun:
-                    if not ca.remove_metadata(metadata_style):
-                        print(f"{ca.path}: Tag removal seemed to fail!")
-                    else:
-                        print(f"{ca.path}: Removed {style_name} tags.")
+                if opts.raw:
+                    print("{0}".format(ca.readRawCoMet()))
                 else:
-                    print(f"{ca.path}: dry-run. {style_name} tags not removed")
-            else:
-                print(f"{ca.path}: This archive doesn't have {style_name} tags to remove.")
+                    print("{0}".format(ca.readCoMet()))
 
-    def copy(self, ca: ComicArchive) -> None:
-        for metadata_style in self.config.runtime_type:
-            dst_style_name = MetaDataStyle.name[metadata_style]
-            if not self.config.runtime_overwrite and ca.has_metadata(metadata_style):
-                print(f"{ca.path}: Already has {dst_style_name} tags. Not overwriting.")
-                return
-            if self.config.commands_copy == metadata_style:
-                print(f"{ca.path}: Destination and source are same: {dst_style_name}. Nothing to do.")
-                return
-
-            src_style_name = MetaDataStyle.name[self.config.commands_copy]
-            if ca.has_metadata(self.config.commands_copy):
-                if not self.config.runtime_dryrun:
-                    try:
-                        md = ca.read_metadata(self.config.commands_copy)
-                    except Exception as e:
-                        md = GenericMetadata()
-                        logger.error("Failed to load metadata for %s: %s", ca.path, e)
-
-                    if self.config.apply_transform_on_bulk_operation_ndetadata_style == MetaDataStyle.CBI:
-                        md = CBLTransformer(md, self.config).apply()
-
-                    if not ca.write_metadata(md, metadata_style):
-                        print(f"{ca.path}: Tag copy seemed to fail!")
-                    else:
-                        print(f"{ca.path}: Copied {src_style_name} tags to {dst_style_name}.")
+    elif opts.delete_tags:
+        style_name = MetaDataStyle.name[opts.data_style]
+        if has[opts.data_style]:
+            if not opts.dryrun:
+                if not ca.removeMetadata(opts.data_style):
+                    print("{0}: Tag removal seemed to fail!".format(filename))
                 else:
-                    print(f"{ca.path}: dry-run.  {src_style_name} tags not copied")
+                    print("{0}: Removed {1} tags.".format(filename, style_name))
             else:
-                print(f"{ca.path}: This archive doesn't have {src_style_name} tags to copy.")
+                print("{0}: dry-run. {1} tags not removed".format(filename, style_name))
+        else:
+            print("{0}: This archive doesn't have {1} tags to remove.".format(filename, style_name))
 
-    def save(self, ca: ComicArchive, match_results: OnlineMatchResults) -> None:
-        if not self.config.runtime_overwrite:
-            for metadata_style in self.config.runtime_type:
-                if ca.has_metadata(metadata_style):
-                    print(f"{ca.path}: Already has {MetaDataStyle.name[metadata_style]} tags. Not overwriting.")
-                    return
+    elif opts.copy_tags:
+        dst_style_name = MetaDataStyle.name[opts.data_style]
+        if opts.no_overwrite and has[opts.data_style]:
+            print("{0}: Already has {1} tags. Not overwriting.".format(filename, dst_style_name))
+            return
+        if opts.copy_source == opts.data_style:
+            print("{0}: Destination and source are same: {1}. Nothing to do.".format(filename, dst_style_name))
+            return
 
-        if self.batch_mode:
-            print(f"Processing {ca.path}...")
+        src_style_name = MetaDataStyle.name[opts.copy_source]
+        if has[opts.copy_source]:
+            if not opts.dryrun:
+                md = ca.readMetadata(opts.copy_source)
 
-        md = self.create_local_metadata(ca)
+                if settings.apply_cbl_transform_on_bulk_operation and opts.data_style == MetaDataStyle.CBI:
+                    md = CBLTransformer(md, settings).apply()
+
+                if not ca.writeMetadata(md, opts.data_style):
+                    print("{0}: Tag copy seemed to fail!".format(filename))
+                else:
+                    print("{0}: Copied {1} tags to {2} .".format(filename, src_style_name, dst_style_name))
+            else:
+                print("{0}: dry-run.  {1} tags not copied".format(filename, src_style_name))
+        else:
+            print("{0}: This archive doesn't have {1} tags to copy.".format(filename, src_style_name))
+
+    elif opts.save_tags:
+
+        if opts.no_overwrite and has[opts.data_style]:
+            print("{0}: Already has {1} tags. Not overwriting.".format(filename, MetaDataStyle.name[opts.data_style]))
+            return
+
+        if batch_mode:
+            print("Processing {0}...".format(filename))
+
+        md = create_local_metadata(opts, ca, has[opts.data_style])
         if md.issue is None or md.issue == "":
-            if self.config.runtime_assume_issue_one:
+            if opts.assume_issue_is_one_if_not_set:
                 md.issue = "1"
 
         # now, search online
-        if self.config.runtime_online:
-            if self.config.runtime_issue_id is not None:
-                # we were given the actual issue ID to search with
+        if opts.search_online:
+            if opts.issue_id is not None:
+                # we were given the actual ID to search with
                 try:
-                    ct_md = self.current_talker().fetch_comic_data(self.config.runtime_issue_id)
-                except TalkerError as e:
-                    logger.exception(f"Error retrieving issue details. Save aborted.\n{e}")
-                    match_results.fetch_data_failures.append(str(ca.path.absolute()))
+                    comicVine = ComicVineTalker()
+                    comicVine.wait_for_rate_limit = opts.wait_and_retry_on_rate_limit
+                    cv_md = comicVine.fetchIssueDataByIssueID(opts.issue_id, settings)
+                except ComicVineTalkerException:
+                    print("Network error while getting issue details.  Save aborted", file=sys.stderr)
+                    match_results.fetchDataFailures.append(filename)
                     return
 
-                if ct_md is None:
-                    logger.error("No match for ID %s was found.", self.config.runtime_issue_id)
-                    match_results.no_matches.append(str(ca.path.absolute()))
+                if cv_md is None:
+                    print("No match for ID {0} was found.".format(opts.issue_id), file=sys.stderr)
+                    match_results.noMatches.append(filename)
                     return
 
-                if self.config.cbl_apply_transform_on_import:
-                    ct_md = CBLTransformer(ct_md, self.config).apply()
+                if settings.apply_cbl_transform_on_cv_import:
+                    cv_md = CBLTransformer(cv_md, settings).apply()
             else:
-                if md is None or md.is_empty:
-                    logger.error("No metadata given to search online with!")
-                    match_results.no_matches.append(str(ca.path.absolute()))
+                ii = IssueIdentifier(ca, settings)
+
+                if md is None or md.isEmpty:
+                    print("No metadata given to search online with!", file=sys.stderr)
+                    match_results.noMatches.append(filename)
                     return
 
-                ii = IssueIdentifier(ca, self.config, self.current_talker())
+                def myoutput(text):
+                    if opts.verbose:
+                        IssueIdentifier.defaultWriteOutput(text)
 
-                def myoutput(text: str) -> None:
-                    if self.config.runtime_verbose:
-                        IssueIdentifier.default_write_output(text)
-
-                # use our overlaid MD struct to search
-                ii.set_additional_metadata(md)
-                ii.only_use_additional_meta_data = True
-                ii.set_output_function(myoutput)
-                ii.cover_page_index = md.get_cover_page_index_list()[0]
+                # use our overlayed MD struct to search
+                ii.setAdditionalMetadata(md)
+                ii.onlyUseAdditionalMetaData = True
+                ii.waitAndRetryOnRateLimit = opts.wait_and_retry_on_rate_limit
+                ii.setOutputFunction(myoutput)
+                ii.cover_page_index = md.getCoverPageIndexList()[0]
                 matches = ii.search()
 
                 result = ii.search_result
@@ -386,211 +387,168 @@ class CLI:
                 choices = False
                 low_confidence = False
 
-                if result == ii.result_no_matches:
+                if result == ii.ResultNoMatches:
                     pass
-                elif result == ii.result_found_match_but_bad_cover_score:
+                elif result == ii.ResultFoundMatchButBadCoverScore:
                     low_confidence = True
                     found_match = True
-                elif result == ii.result_found_match_but_not_first_page:
+                elif result == ii.ResultFoundMatchButNotFirstPage:
                     found_match = True
-                elif result == ii.result_multiple_matches_with_bad_image_scores:
+                elif result == ii.ResultMultipleMatchesWithBadImageScores:
                     low_confidence = True
                     choices = True
-                elif result == ii.result_one_good_match:
+                elif result == ii.ResultOneGoodMatch:
                     found_match = True
-                elif result == ii.result_multiple_good_matches:
+                elif result == ii.ResultMultipleGoodMatches:
                     choices = True
 
                 if choices:
                     if low_confidence:
-                        logger.error("Online search: Multiple low confidence matches. Save aborted")
-                        match_results.low_confidence_matches.append(MultipleMatch(ca, matches))
+                        print("Online search: Multiple low confidence matches.  Save aborted", file=sys.stderr)
+                        match_results.lowConfidenceMatches.append(MultipleMatch(filename, matches))
                         return
-
-                    logger.error("Online search: Multiple good matches. Save aborted")
-                    match_results.multiple_matches.append(MultipleMatch(ca, matches))
-                    return
-                if low_confidence and self.config.runtime_abort_on_low_confidence:
-                    logger.error("Online search: Low confidence match. Save aborted")
-                    match_results.low_confidence_matches.append(MultipleMatch(ca, matches))
+                    else:
+                        print("Online search: Multiple good matches.  Save aborted", file=sys.stderr)
+                        match_results.multipleMatches.append(MultipleMatch(filename, matches))
+                        return
+                if low_confidence and opts.abortOnLowConfidence:
+                    print("Online search: Low confidence match.  Save aborted", file=sys.stderr)
+                    match_results.lowConfidenceMatches.append(MultipleMatch(filename, matches))
                     return
                 if not found_match:
-                    logger.error("Online search: No match found. Save aborted")
-                    match_results.no_matches.append(str(ca.path.absolute()))
+                    print("Online search: No match found.  Save aborted", file=sys.stderr)
+                    match_results.noMatches.append(filename)
                     return
 
                 # we got here, so we have a single match
 
                 # now get the particular issue data
-                ct_md = self.actual_issue_data_fetch(matches[0]["issue_id"])
-                if ct_md.is_empty:
-                    match_results.fetch_data_failures.append(str(ca.path.absolute()))
+                cv_md = actual_issue_data_fetch(matches[0], settings, opts)
+                if cv_md is None:
+                    match_results.fetchDataFailures.append(filename)
                     return
 
-            if self.config.identifier_clear_metadata_on_import:
-                md = ct_md
-            else:
-                notes = (
-                    f"Tagged with ComicTagger {ctversion.version} using info from Comic Vine on"
-                    f" {datetime.now():%Y-%m-%d %H:%M:%S}.  [Issue ID {ct_md.issue_id}]"
-                )
-                md.overlay(ct_md.replace(notes=utils.combine_notes(md.notes, notes, "Tagged with ComicTagger")))
+            md.overlay(cv_md)
 
-            if self.config.identifier_auto_imprint:
-                md.fix_publisher()
+            if settings.auto_imprint:
+                md.fixPublisher()
 
         # ok, done building our metadata. time to save
-        if not self.actual_metadata_save(ca, md):
-            match_results.write_failures.append(str(ca.path.absolute()))
+        if not actual_metadata_save(ca, opts, md):
+            match_results.writeFailures.append(filename)
         else:
-            match_results.good_matches.append(str(ca.path.absolute()))
+            match_results.goodMatches.append(filename)
+
+    elif opts.rename_file:
 
-    def rename(self, ca: ComicArchive) -> None:
-        original_path = ca.path
         msg_hdr = ""
-        if self.batch_mode:
-            msg_hdr = f"{ca.path}: "
+        if batch_mode:
+            msg_hdr = "{0}: ".format(filename)
 
-        md = self.create_local_metadata(ca)
+        if opts.data_style is not None:
+            use_tags = has[opts.data_style]
+        else:
+            use_tags = False
+
+        md = create_local_metadata(opts, ca, use_tags)
 
         if md.series is None:
-            logger.error(msg_hdr + "Can't rename without series name")
+            print(msg_hdr + "Can't rename without series name", file=sys.stderr)
             return
 
-        new_ext = ""  # default
-        if self.config.rename_set_extension_based_on_archive:
-            new_ext = ca.extension()
+        new_ext = None  # default
+        if settings.rename_extension_based_on_archive:
+            if ca.isZip():
+                new_ext = ".cbz"
+            elif ca.isRar():
+                new_ext = ".cbr"
 
-        renamer = FileRenamer(
-            md,
-            platform="universal" if self.config.rename_strict else "auto",
-            replacements=self.config.rename_replacements,
-        )
-        renamer.set_template(self.config.rename_template)
-        renamer.set_issue_zero_padding(self.config.rename_issue_number_padding)
-        renamer.set_smart_cleanup(self.config.rename_use_smart_string_cleanup)
-        renamer.move = self.config.rename_move_to_dir
+        renamer = FileRenamer(md)
+        renamer.setTemplate(settings.rename_template)
+        renamer.setIssueZeroPadding(settings.rename_issue_number_padding)
+        renamer.setSmartCleanup(settings.rename_use_smart_string_cleanup)
+        renamer.move = settings.rename_move_dir
 
         try:
-            new_name = renamer.determine_name(ext=new_ext)
-        except ValueError:
-            logger.exception(
-                msg_hdr + "Invalid format string!\n"
-                "Your rename template is invalid!\n\n"
-                "%s\n\n"
-                "Please consult the template help in the settings "
+            new_name = renamer.determineName(filename, ext=new_ext)
+        except Exception as e:
+            print(
+                msg_hdr + "Invalid format string!\nYour rename template is invalid!\n\n"
+                "{}\n\nPlease consult the template help in the settings "
                 "and the documentation on the format at "
                 "https://docs.python.org/3/library/string.html#format-string-syntax",
-                self.config.rename_template,
+                file=sys.stderr,
             )
             return
-        except Exception:
-            logger.exception("Formatter failure: %s metadata: %s", self.config.rename_template, renamer.metadata)
 
-        folder = get_rename_dir(ca, self.config.rename_dir if self.config.rename_move_to_dir else None)
+        folder = os.path.dirname(os.path.abspath(filename))
+        if settings.rename_move_dir and len(settings.rename_dir.strip()) > 3:
+            folder = settings.rename_dir.strip()
 
-        full_path = folder / new_name
+        new_abs_path = utils.unique_file(os.path.join(folder, new_name))
 
-        if full_path == ca.path:
+        if os.path.join(folder, new_name) == os.path.abspath(filename):
             print(msg_hdr + "Filename is already good!", file=sys.stderr)
             return
 
         suffix = ""
-        if not self.config.runtime_dryrun:
+        if not opts.dryrun:
             # rename the file
-            try:
-                ca.rename(utils.unique_file(full_path))
-            except OSError:
-                logger.exception("Failed to rename comic archive: %s", ca.path)
+            os.makedirs(os.path.dirname(new_abs_path), 0o777, True)
+            os.rename(filename, new_abs_path)
         else:
             suffix = " (dry-run, no change)"
 
-        print(f"renamed '{original_path.name}' -> '{new_name}' {suffix}")
+        print("renamed '{0}' -> '{1}' {2}".format(os.path.basename(filename), new_name, suffix))
 
-    def export(self, ca: ComicArchive) -> None:
+    elif opts.export_to_zip:
         msg_hdr = ""
-        if self.batch_mode:
-            msg_hdr = f"{ca.path}: "
+        if batch_mode:
+            msg_hdr = "{0}: ".format(filename)
 
-        if ca.is_zip():
-            logger.error(msg_hdr + "Archive is already a zip file.")
+        if not ca.isRar():
+            print(msg_hdr + "Archive is not a RAR.", file=sys.stderr)
             return
 
-        filename_path = ca.path
-        new_file = filename_path.with_suffix(".cbz")
+        rar_file = os.path.abspath(os.path.abspath(filename))
+        new_file = os.path.splitext(rar_file)[0] + ".cbz"
 
-        if self.config.runtime_abort_on_conflict and new_file.exists():
-            print(msg_hdr + f"{new_file.name} already exists in the that folder.")
+        if opts.abort_export_on_conflict and os.path.lexists(new_file):
+            print(msg_hdr + "{0} already exists in the that folder.".format(os.path.split(new_file)[1]))
             return
 
-        new_file = utils.unique_file(new_file)
+        new_file = utils.unique_file(os.path.join(new_file))
 
         delete_success = False
         export_success = False
-        if not self.config.runtime_dryrun:
-            if ca.export_as_zip(new_file):
+        if not opts.dryrun:
+            if ca.exportAsZip(new_file):
                 export_success = True
-                if self.config.runtime_delete_after_zip_export:
+                if opts.delete_rar_after_export:
                     try:
-                        filename_path.unlink(missing_ok=True)
-                        delete_success = True
-                    except OSError:
-                        logger.exception(msg_hdr + "Error deleting original archive after export")
+                        os.unlink(rar_file)
+                    except:
+                        print(msg_hdr + "Error deleting original RAR after export", file=sys.stderr)
                         delete_success = False
+                    else:
+                        delete_success = True
             else:
                 # last export failed, so remove the zip, if it exists
-                new_file.unlink(missing_ok=True)
+                if os.path.lexists(new_file):
+                    os.remove(new_file)
         else:
-            msg = msg_hdr + f"Dry-run:  Would try to create {os.path.split(new_file)[1]}"
-            if self.config.runtime_delete_after_zip_export:
-                msg += " and delete original."
+            msg = msg_hdr + "Dry-run:  Would try to create {0}".format(os.path.split(new_file)[1])
+            if opts.delete_rar_after_export:
+                msg += " and delete orginal."
             print(msg)
             return
 
         msg = msg_hdr
         if export_success:
-            msg += f"Archive exported successfully to: {os.path.split(new_file)[1]}"
-            if self.config.runtime_delete_after_zip_export and delete_success:
+            msg += "Archive exported successfully to: {0}".format(os.path.split(new_file)[1])
+            if opts.delete_rar_after_export and delete_success:
                 msg += " (Original deleted) "
         else:
             msg += "Archive failed to export!"
 
         print(msg)
-
-    def process_file_cli(self, filename: str, match_results: OnlineMatchResults) -> None:
-        if not os.path.lexists(filename):
-            logger.error("Cannot find %s", filename)
-            return
-
-        ca = ComicArchive(filename, str(graphics_path / "nocover.png"))
-
-        if not ca.seems_to_be_a_comic_archive():
-            logger.error("Sorry, but %s is not a comic archive!", filename)
-            return
-
-        if not ca.is_writable() and (
-            self.config.commands_delete
-            or self.config.commands_copy
-            or self.config.commands_save
-            or self.config.commands_rename
-        ):
-            logger.error("This archive is not writable")
-            return
-
-        if self.config.commands_print:
-            self.print(ca)
-
-        elif self.config.commands_delete:
-            self.delete(ca)
-
-        elif self.config.commands_copy is not None:
-            self.copy(ca)
-
-        elif self.config.commands_save:
-            self.save(ca, match_results)
-
-        elif self.config.commands_rename:
-            self.rename(ca)
-
-        elif self.config.commands_export_to_zip:
-            self.export(ca)

comictaggerlib/comet.py

@@ -0,0 +1 @@
+from comicapi.comet import *

comictaggerlib/comicarchive.py

@@ -0,0 +1 @@
+from comicapi.comicarchive import *

comictaggerlib/comicbookinfo.py

@@ -0,0 +1 @@
+from comicapi.comicbookinfo import *

comictaggerlib/comicinfoxml.py

@@ -0,0 +1 @@
+from comicapi.comicinfoxml import *

comictaggerlib/comicvinecacher.py

@@ -0,0 +1,442 @@
+"""A python class to manage caching of data from Comic Vine"""
+
+# Copyright 2012-2014 Anthony Beville
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import datetime
+import os
+import sqlite3 as lite
+
+from . import _version, utils
+from .settings import ComicTaggerSettings
+
+
+class ComicVineCacher:
+    def __init__(self):
+        self.settings_folder = ComicTaggerSettings.getSettingsFolder()
+        self.db_file = os.path.join(self.settings_folder, "cv_cache.db")
+        self.version_file = os.path.join(self.settings_folder, "cache_version.txt")
+
+        # verify that cache is from same version as this one
+        data = ""
+        try:
+            with open(self.version_file, "rb") as f:
+                data = f.read().decode("utf-8")
+                f.close()
+        except:
+            pass
+        if data != _version.version:
+            self.clearCache()
+
+        if not os.path.exists(self.db_file):
+            self.create_cache_db()
+
+    def clearCache(self):
+        try:
+            os.unlink(self.db_file)
+        except:
+            pass
+        try:
+            os.unlink(self.version_file)
+        except:
+            pass
+
+    def create_cache_db(self):
+
+        # create the version file
+        with open(self.version_file, "w") as f:
+            f.write(_version.version)
+
+        # this will wipe out any existing version
+        open(self.db_file, "w").close()
+
+        con = lite.connect(self.db_file)
+
+        # create tables
+        with con:
+
+            cur = con.cursor()
+            # name,id,start_year,publisher,image,description,count_of_issues
+            cur.execute(
+                "CREATE TABLE VolumeSearchCache("
+                + "search_term TEXT,"
+                + "id INT,"
+                + "name TEXT,"
+                + "start_year INT,"
+                + "publisher TEXT,"
+                + "count_of_issues INT,"
+                + "image_url TEXT,"
+                + "description TEXT,"
+                + "timestamp DATE DEFAULT (datetime('now','localtime'))) "
+            )
+
+            cur.execute(
+                "CREATE TABLE Volumes("
+                + "id INT,"
+                + "name TEXT,"
+                + "publisher TEXT,"
+                + "count_of_issues INT,"
+                + "start_year INT,"
+                + "timestamp DATE DEFAULT (datetime('now','localtime')), "
+                + "PRIMARY KEY (id))"
+            )
+
+            cur.execute(
+                "CREATE TABLE AltCovers("
+                + "issue_id INT,"
+                + "url_list TEXT,"
+                + "timestamp DATE DEFAULT (datetime('now','localtime')), "
+                + "PRIMARY KEY (issue_id))"
+            )
+
+            cur.execute(
+                "CREATE TABLE Issues("
+                + "id INT,"
+                + "volume_id INT,"
+                + "name TEXT,"
+                + "issue_number TEXT,"
+                + "super_url TEXT,"
+                + "thumb_url TEXT,"
+                + "cover_date TEXT,"
+                + "site_detail_url TEXT,"
+                + "description TEXT,"
+                + "timestamp DATE DEFAULT (datetime('now','localtime')), "
+                + "PRIMARY KEY (id))"
+            )
+
+    def add_search_results(self, search_term, cv_search_results):
+
+        con = lite.connect(self.db_file)
+
+        with con:
+            con.text_factory = str
+            cur = con.cursor()
+
+            # remove all previous entries with this search term
+            cur.execute("DELETE FROM VolumeSearchCache WHERE search_term = ?", [search_term.lower()])
+
+            # now add in new results
+            for record in cv_search_results:
+                timestamp = datetime.datetime.now()
+
+                if record["publisher"] is None:
+                    pub_name = ""
+                else:
+                    pub_name = record["publisher"]["name"]
+
+                if record["image"] is None:
+                    url = ""
+                else:
+                    url = record["image"]["super_url"]
+
+                cur.execute(
+                    "INSERT INTO VolumeSearchCache "
+                    + "(search_term, id, name, start_year, publisher, count_of_issues, image_url, description) "
+                    + "VALUES(?, ?, ?, ?, ?, ?, ?, ?)",
+                    (
+                        search_term.lower(),
+                        record["id"],
+                        record["name"],
+                        record["start_year"],
+                        pub_name,
+                        record["count_of_issues"],
+                        url,
+                        record["description"],
+                    ),
+                )
+
+    def get_search_results(self, search_term):
+
+        results = list()
+        con = lite.connect(self.db_file)
+        with con:
+            con.text_factory = str
+            cur = con.cursor()
+
+            # purge stale search results
+            a_day_ago = datetime.datetime.today() - datetime.timedelta(days=1)
+            cur.execute("DELETE FROM VolumeSearchCache WHERE timestamp  < ?", [str(a_day_ago)])
+
+            # fetch
+            cur.execute("SELECT * FROM VolumeSearchCache WHERE search_term=?", [search_term.lower()])
+            rows = cur.fetchall()
+            # now process the results
+            for record in rows:
+
+                result = dict()
+                result["id"] = record[1]
+                result["name"] = record[2]
+                result["start_year"] = record[3]
+                result["publisher"] = dict()
+                result["publisher"]["name"] = record[4]
+                result["count_of_issues"] = record[5]
+                result["image"] = dict()
+                result["image"]["super_url"] = record[6]
+                result["description"] = record[7]
+
+                results.append(result)
+
+        return results
+
+    def add_alt_covers(self, issue_id, url_list):
+
+        con = lite.connect(self.db_file)
+
+        with con:
+            con.text_factory = str
+            cur = con.cursor()
+
+            # remove all previous entries with this search term
+            cur.execute("DELETE FROM AltCovers WHERE issue_id = ?", [issue_id])
+
+            url_list_str = utils.listToString(url_list)
+            # now add in new record
+            cur.execute("INSERT INTO AltCovers " + "(issue_id, url_list) " + "VALUES(?, ?)", (issue_id, url_list_str))
+
+    def get_alt_covers(self, issue_id):
+
+        con = lite.connect(self.db_file)
+        with con:
+            cur = con.cursor()
+            con.text_factory = str
+
+            # purge stale issue info - probably issue data won't change
+            # much....
+            a_month_ago = datetime.datetime.today() - datetime.timedelta(days=30)
+            cur.execute("DELETE FROM AltCovers WHERE timestamp  < ?", [str(a_month_ago)])
+
+            cur.execute("SELECT url_list FROM AltCovers WHERE issue_id=?", [issue_id])
+            row = cur.fetchone()
+            if row is None:
+                return None
+            else:
+                url_list_str = row[0]
+                if len(url_list_str) == 0:
+                    return []
+                raw_list = url_list_str.split(",")
+                url_list = []
+                for item in raw_list:
+                    url_list.append(str(item).strip())
+                return url_list
+
+    def add_volume_info(self, cv_volume_record):
+
+        con = lite.connect(self.db_file)
+
+        with con:
+
+            cur = con.cursor()
+
+            timestamp = datetime.datetime.now()
+
+            if cv_volume_record["publisher"] is None:
+                pub_name = ""
+            else:
+                pub_name = cv_volume_record["publisher"]["name"]
+
+            data = {
+                "name": cv_volume_record["name"],
+                "publisher": pub_name,
+                "count_of_issues": cv_volume_record["count_of_issues"],
+                "start_year": cv_volume_record["start_year"],
+                "timestamp": timestamp,
+            }
+            self.upsert(cur, "volumes", "id", cv_volume_record["id"], data)
+
+    def add_volume_issues_info(self, volume_id, cv_volume_issues):
+
+        con = lite.connect(self.db_file)
+
+        with con:
+
+            cur = con.cursor()
+
+            timestamp = datetime.datetime.now()
+
+            # add in issues
+
+            for issue in cv_volume_issues:
+
+                data = {
+                    "volume_id": volume_id,
+                    "name": issue["name"],
+                    "issue_number": issue["issue_number"],
+                    "site_detail_url": issue["site_detail_url"],
+                    "cover_date": issue["cover_date"],
+                    "super_url": issue["image"]["super_url"],
+                    "thumb_url": issue["image"]["thumb_url"],
+                    "description": issue["description"],
+                    "timestamp": timestamp,
+                }
+                self.upsert(cur, "issues", "id", issue["id"], data)
+
+    def get_volume_info(self, volume_id):
+
+        result = None
+
+        con = lite.connect(self.db_file)
+        with con:
+            cur = con.cursor()
+            con.text_factory = str
+
+            # purge stale volume info
+            a_week_ago = datetime.datetime.today() - datetime.timedelta(days=7)
+            cur.execute("DELETE FROM Volumes WHERE timestamp  < ?", [str(a_week_ago)])
+
+            # fetch
+            cur.execute("SELECT id,name,publisher,count_of_issues,start_year FROM Volumes WHERE id = ?", [volume_id])
+
+            row = cur.fetchone()
+
+            if row is None:
+                return result
+
+            result = dict()
+
+            # since ID is primary key, there is only one row
+            result["id"] = row[0]
+            result["name"] = row[1]
+            result["publisher"] = dict()
+            result["publisher"]["name"] = row[2]
+            result["count_of_issues"] = row[3]
+            result["start_year"] = row[4]
+            result["issues"] = list()
+
+        return result
+
+    def get_volume_issues_info(self, volume_id):
+
+        result = None
+
+        con = lite.connect(self.db_file)
+        with con:
+            cur = con.cursor()
+            con.text_factory = str
+
+            # purge stale issue info - probably issue data won't change
+            # much....
+            a_week_ago = datetime.datetime.today() - datetime.timedelta(days=7)
+            cur.execute("DELETE FROM Issues WHERE timestamp  < ?", [str(a_week_ago)])
+
+            # fetch
+            results = list()
+
+            cur.execute(
+                "SELECT id,name,issue_number,site_detail_url,cover_date,super_url,thumb_url,description FROM Issues WHERE volume_id = ?", [volume_id]
+            )
+            rows = cur.fetchall()
+
+            # now process the results
+            for row in rows:
+                record = dict()
+
+                record["id"] = row[0]
+                record["name"] = row[1]
+                record["issue_number"] = row[2]
+                record["site_detail_url"] = row[3]
+                record["cover_date"] = row[4]
+                record["image"] = dict()
+                record["image"]["super_url"] = row[5]
+                record["image"]["thumb_url"] = row[6]
+                record["description"] = row[7]
+
+                results.append(record)
+
+        if len(results) == 0:
+            return None
+
+        return results
+
+    def add_issue_select_details(self, issue_id, image_url, thumb_image_url, cover_date, site_detail_url):
+
+        con = lite.connect(self.db_file)
+
+        with con:
+            cur = con.cursor()
+            con.text_factory = str
+            timestamp = datetime.datetime.now()
+
+            data = {
+                "super_url": image_url,
+                "thumb_url": thumb_image_url,
+                "cover_date": cover_date,
+                "site_detail_url": site_detail_url,
+                "timestamp": timestamp,
+            }
+            self.upsert(cur, "issues", "id", issue_id, data)
+
+    def get_issue_select_details(self, issue_id):
+
+        con = lite.connect(self.db_file)
+        with con:
+            cur = con.cursor()
+            con.text_factory = str
+
+            cur.execute("SELECT super_url,thumb_url,cover_date,site_detail_url FROM Issues WHERE id=?", [issue_id])
+            row = cur.fetchone()
+
+            details = dict()
+            if row is None or row[0] is None:
+                details["image_url"] = None
+                details["thumb_image_url"] = None
+                details["cover_date"] = None
+                details["site_detail_url"] = None
+
+            else:
+                details["image_url"] = row[0]
+                details["thumb_image_url"] = row[1]
+                details["cover_date"] = row[2]
+                details["site_detail_url"] = row[3]
+
+            return details
+
+    def upsert(self, cur, tablename, pkname, pkval, data):
+        """This does an insert if the given PK doesn't exist, and an
+        update it if does
+
+        TODO: look into checking if UPDATE is needed
+        TODO: should the cursor be created here, and not up the stack?
+        """
+
+        ins_count = len(data) + 1
+
+        keys = ""
+        vals = list()
+        ins_slots = ""
+        set_slots = ""
+
+        for key in data:
+
+            if keys != "":
+                keys += ", "
+            if ins_slots != "":
+                ins_slots += ", "
+            if set_slots != "":
+                set_slots += ", "
+
+            keys += key
+            vals.append(data[key])
+            ins_slots += "?"
+            set_slots += key + " = ?"
+
+        keys += ", " + pkname
+        vals.append(pkval)
+        ins_slots += ", ?"
+        condition = pkname + " = ?"
+
+        sql_ins = "INSERT OR IGNORE INTO " + tablename + " (" + keys + ") " + " VALUES (" + ins_slots + ")"
+        cur.execute(sql_ins, vals)
+
+        sql_upd = "UPDATE " + tablename + " SET " + set_slots + " WHERE " + condition
+        cur.execute(sql_upd, vals)

comictaggerlib/comicvinetalker.py

@@ -0,0 +1,883 @@
+"""A python class to manage communication with Comic Vine's REST API"""
+
+# Copyright 2012-2014 Anthony Beville
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import datetime
+import json
+import re
+import ssl
+import sys
+import time
+import unicodedata
+
+import requests
+from bs4 import BeautifulSoup
+
+from . import _version, utils
+from .comicvinecacher import ComicVineCacher
+from .genericmetadata import GenericMetadata
+from .issuestring import IssueString
+
+try:
+    from PyQt5.QtCore import QByteArray, QObject, QUrl, pyqtSignal
+    from PyQt5.QtNetwork import QNetworkAccessManager, QNetworkRequest
+except ImportError:
+    # No Qt, so define a few dummy QObjects to help us compile
+    class QObject:
+        def __init__(self, *args):
+            pass
+
+    class pyqtSignal:
+        def __init__(self, *args):
+            pass
+
+        def emit(a, b, c):
+            pass
+
+
+# from settings import ComicTaggerSettings
+
+
+class CVTypeID:
+    Volume = "4050"
+    Issue = "4000"
+
+
+class ComicVineTalkerException(Exception):
+    Unknown = -1
+    Network = -2
+    InvalidKey = 100
+    RateLimit = 107
+
+    def __init__(self, code=-1, desc=""):
+        self.desc = desc
+        self.code = code
+
+    def __str__(self):
+        if self.code == ComicVineTalkerException.Unknown or self.code == ComicVineTalkerException.Network:
+            return self.desc
+        else:
+            return "CV error #{0}:  [{1}]. \n".format(self.code, self.desc)
+
+
+class ComicVineTalker(QObject):
+
+    logo_url = "http://static.comicvine.com/bundles/comicvinesite/images/logo.png"
+    api_key = ""
+
+    @staticmethod
+    def getRateLimitMessage():
+        if ComicVineTalker.api_key == "":
+            return "Comic Vine rate limit exceeded.  You should configue your own Comic Vine API key."
+        else:
+            return "Comic Vine rate limit exceeded.  Please wait a bit."
+
+    def __init__(self):
+        QObject.__init__(self)
+
+        self.api_base_url = "https://comicvine.gamespot.com/api"
+        self.wait_for_rate_limit = False
+
+        # key that is registered to comictagger
+        default_api_key = "27431e6787042105bd3e47e169a624521f89f3a4"
+
+        if ComicVineTalker.api_key == "":
+            self.api_key = default_api_key
+        else:
+            self.api_key = ComicVineTalker.api_key
+
+        self.log_func = None
+
+    def setLogFunc(self, log_func):
+        self.log_func = log_func
+
+    def writeLog(self, text):
+        if self.log_func is None:
+            # sys.stdout.write(text.encode(errors='replace'))
+            # sys.stdout.flush()
+            print(text, file=sys.stderr)
+        else:
+            self.log_func(text)
+
+    def parseDateStr(self, date_str):
+        day = None
+        month = None
+        year = None
+        if date_str is not None:
+            parts = date_str.split("-")
+            year = utils.xlate(parts[0], True)
+            if len(parts) > 1:
+                month = utils.xlate(parts[1], True)
+                if len(parts) > 2:
+                    day = utils.xlate(parts[2], True)
+        return day, month, year
+
+    def testKey(self, key):
+
+        try:
+            test_url = self.api_base_url + "/issue/1/?api_key=" + key + "&format=json&field_list=name"
+
+            cv_response = requests.get(test_url, headers={"user-agent": "comictagger/" + _version.version}).json()
+
+            # Bogus request, but if the key is wrong, you get error 100: "Invalid
+            # API Key"
+            return cv_response["status_code"] != 100
+        except:
+            return False
+
+    """
+    Get the contect from the CV server.  If we're in "wait mode" and status code is a rate limit error
+    sleep for a bit and retry.
+    """
+
+    def getCVContent(self, url, params):
+        total_time_waited = 0
+        limit_wait_time = 1
+        counter = 0
+        wait_times = [1, 2, 3, 4]
+        while True:
+            cv_response = self.getUrlContent(url, params)
+            if self.wait_for_rate_limit and cv_response["status_code"] == ComicVineTalkerException.RateLimit:
+                self.writeLog("Rate limit encountered.  Waiting for {0} minutes\n".format(limit_wait_time))
+                time.sleep(limit_wait_time * 60)
+                total_time_waited += limit_wait_time
+                limit_wait_time = wait_times[counter]
+                if counter < 3:
+                    counter += 1
+                # don't wait much more than 20 minutes
+                if total_time_waited < 20:
+                    continue
+            if cv_response["status_code"] != 1:
+                self.writeLog("Comic Vine query failed with error #{0}:  [{1}]. \n".format(cv_response["status_code"], cv_response["error"]))
+                raise ComicVineTalkerException(cv_response["status_code"], cv_response["error"])
+            else:
+                # it's all good
+                break
+        return cv_response
+
+    def getUrlContent(self, url, params):
+        # connect to server:
+        #  if there is a 500 error, try a few more times before giving up
+        #  any other error, just bail
+        # print("---", url)
+        for tries in range(3):
+            try:
+                resp = requests.get(url, params=params, headers={"user-agent": "comictagger/" + _version.version})
+                if resp.status_code == 200:
+                    return resp.json()
+                if resp.status_code == 500:
+                    self.writeLog("Try #{0}: ".format(tries + 1))
+                    time.sleep(1)
+                    self.writeLog(str(resp.status_code) + "\n")
+                else:
+                    break
+
+            except requests.exceptions.RequestException as e:
+                self.writeLog(str(e) + "\n")
+                raise ComicVineTalkerException(ComicVineTalkerException.Network, "Network Error!")
+
+        raise ComicVineTalkerException(ComicVineTalkerException.Unknown, "Error on Comic Vine server")
+
+    def literalSearchForSeries(self, series_name, callback=None):
+
+        # normalize unicode and convert to ascii. Does not work for everything eg ½ to 1⁄2 not 1/2
+        search_series_name = unicodedata.normalize("NFKD", series_name).encode("ascii", "ignore").decode("ascii")
+
+        params = {
+            "api_key": self.api_key,
+            "format": "json",
+            "resources": "volume",
+            "query": search_series_name,
+            "field_list": "volume,name,id,start_year,publisher,image,description,count_of_issues",
+            "page": 1,
+            "limit": 100,
+        }
+
+        cv_response = self.getCVContent(self.api_base_url + "/search", params)
+
+        search_results = list()
+
+        # see http://api.comicvine.com/documentation/#handling_responses
+
+        limit = cv_response["limit"]
+        current_result_count = cv_response["number_of_page_results"]
+        total_result_count = cv_response["number_of_total_results"]
+
+        # 8 Dec 2018 - Comic Vine changed query results again. Terms are now
+        # ORed together, and we get thousands of results.  Good news is the
+        # results are sorted by relevance, so we can be smart about halting
+        # the search.
+        # 1. Don't fetch more than some sane amount of pages.
+        max_results = 50
+
+        total_result_count = min(total_result_count, max_results)
+
+        if callback is None:
+            self.writeLog("Found {0} of {1} results\n".format(cv_response["number_of_page_results"], cv_response["number_of_total_results"]))
+        search_results.extend(cv_response["results"])
+        page = 1
+
+        if callback is not None:
+            callback(current_result_count, total_result_count)
+
+        # see if we need to keep asking for more pages...
+        while current_result_count < total_result_count:
+            if callback is None:
+                self.writeLog("getting another page of results {0} of {1}...\n".format(current_result_count, total_result_count))
+            page += 1
+
+            params["page"] = page
+            cv_response = self.getCVContent(self.api_base_url + "/search", params)
+
+            search_results.extend(cv_response["results"])
+            current_result_count += cv_response["number_of_page_results"]
+
+            if callback is not None:
+                callback(current_result_count, total_result_count)
+
+        return search_results
+
+    def searchForSeries(self, series_name, callback=None, refresh_cache=False):
+
+        # normalize unicode and convert to ascii. Does not work for everything eg ½ to 1⁄2 not 1/2
+        search_series_name = unicodedata.normalize("NFKD", series_name).encode("ascii", "ignore").decode("ascii")
+        # comicvine ignores punctuation and accents
+        search_series_name = re.sub(r"[^A-Za-z0-9]+", " ", search_series_name)
+        # remove extra space and articles and all lower case
+        search_series_name = utils.removearticles(search_series_name).lower().strip()
+
+        # before we search online, look in our cache, since we might have
+        # done this same search recently
+        cvc = ComicVineCacher()
+        if not refresh_cache:
+            cached_search_results = cvc.get_search_results(series_name)
+
+            if len(cached_search_results) > 0:
+                return cached_search_results
+
+        params = {
+            "api_key": self.api_key,
+            "format": "json",
+            "resources": "volume",
+            "query": search_series_name,
+            "field_list": "volume,name,id,start_year,publisher,image,description,count_of_issues",
+            "page": 1,
+            "limit": 100,
+        }
+
+        cv_response = self.getCVContent(self.api_base_url + "/search", params)
+
+        search_results = list()
+
+        # see http://api.comicvine.com/documentation/#handling_responses
+
+        limit = cv_response["limit"]
+        current_result_count = cv_response["number_of_page_results"]
+        total_result_count = cv_response["number_of_total_results"]
+
+        # 8 Dec 2018 - Comic Vine changed query results again. Terms are now
+        # ORed together, and we get thousands of results.  Good news is the
+        # results are sorted by relevance, so we can be smart about halting
+        # the search.
+        # 1. Don't fetch more than some sane amount of pages.
+        max_results = 500
+        # 2. Halt when not all of our search terms are present in a result
+        # 3. Halt when the results contain more (plus threshold) words than
+        #    our search
+        result_word_count_max = len(search_series_name.split()) + 3
+
+        total_result_count = min(total_result_count, max_results)
+
+        if callback is None:
+            self.writeLog("Found {0} of {1} results\n".format(cv_response["number_of_page_results"], cv_response["number_of_total_results"]))
+        search_results.extend(cv_response["results"])
+        page = 1
+
+        if callback is not None:
+            callback(current_result_count, total_result_count)
+
+        # see if we need to keep asking for more pages...
+        stop_searching = False
+        while current_result_count < total_result_count:
+
+            last_result = search_results[-1]["name"]
+
+            # normalize unicode and convert to ascii. Does not work for everything eg ½ to 1⁄2 not 1/2
+            last_result = unicodedata.normalize("NFKD", last_result).encode("ascii", "ignore").decode("ascii")
+            # comicvine ignores punctuation and accents
+            last_result = re.sub(r"[^A-Za-z0-9]+", " ", last_result)
+            # remove extra space and articles and all lower case
+            last_result = utils.removearticles(last_result).lower().strip()
+
+            # See if the last result's name has all the of the search terms.
+            # if not, break out of this, loop, we're done.
+            for term in search_series_name.split():
+                if term not in last_result.lower():
+                    # print("Term '{}' not in last result. Halting search result fetching".format(term))
+                    stop_searching = True
+                    break
+
+            # Also, stop searching when the word count of last results is too much longer
+            # than our search terms list
+            if len(last_result.split()) > result_word_count_max:
+                print(
+                    "Last result '{}' is too long: max word count: {}; Search terms {}. Halting search result fetching".format(
+                        last_result, result_word_count_max, search_series_name.split()
+                    ),
+                    file=sys.stderr,
+                )
+                stop_searching = True
+
+            if stop_searching:
+                break
+
+            if callback is None:
+                self.writeLog("getting another page of results {0} of {1}...\n".format(current_result_count, total_result_count))
+            page += 1
+
+            params["page"] = page
+            cv_response = self.getCVContent(self.api_base_url + "/search", params)
+
+            search_results.extend(cv_response["results"])
+            current_result_count += cv_response["number_of_page_results"]
+
+            if callback is not None:
+                callback(current_result_count, total_result_count)
+
+        # Remove any search results that don't contain all the search terms
+        # (iterate backwards for easy removal)
+        for i in range(len(search_results) - 1, -1, -1):
+            record = search_results[i]
+            for term in search_series_name.split():
+                # normalize unicode and convert to ascii. Does not work for everything eg ½ to 1⁄2 not 1/2
+                recordName = unicodedata.normalize("NFKD", record["name"]).encode("ascii", "ignore").decode("ascii")
+                # comicvine ignores punctuation and accents
+                recordName = re.sub(r"[^A-Za-z0-9]+", " ", recordName)
+                # remove extra space and articles and all lower case
+                recordName = utils.removearticles(recordName).lower().strip()
+
+                if term not in recordName:
+                    del search_results[i]
+                    break
+
+        # for record in search_results:
+        # print(u"{0}: {1} ({2})".format(record['id'], record['name'] , record['start_year']))
+        # print(record)
+        # record['count_of_issues'] = record['count_of_isssues']
+        # print(u"{0}: {1} ({2})".format(search_results['results'][0]['id'], search_results['results'][0]['name'] , search_results['results'][0]['start_year']))
+
+        # cache these search results
+        cvc.add_search_results(series_name, search_results)
+
+        return search_results
+
+    def fetchVolumeData(self, series_id):
+
+        # before we search online, look in our cache, since we might already
+        # have this info
+        cvc = ComicVineCacher()
+        cached_volume_result = cvc.get_volume_info(series_id)
+
+        if cached_volume_result is not None:
+            return cached_volume_result
+
+        volume_url = self.api_base_url + "/volume/" + CVTypeID.Volume + "-" + str(series_id)
+
+        params = {"api_key": self.api_key, "format": "json", "field_list": "name,id,start_year,publisher,count_of_issues"}
+        cv_response = self.getCVContent(volume_url, params)
+
+        volume_results = cv_response["results"]
+
+        cvc.add_volume_info(volume_results)
+
+        return volume_results
+
+    def fetchIssuesByVolume(self, series_id):
+
+        # before we search online, look in our cache, since we might already
+        # have this info
+        cvc = ComicVineCacher()
+        cached_volume_issues_result = cvc.get_volume_issues_info(series_id)
+
+        if cached_volume_issues_result is not None:
+            return cached_volume_issues_result
+
+        params = {
+            "api_key": self.api_key,
+            "filter": "volume:" + str(series_id),
+            "format": "json",
+            "field_list": "id,volume,issue_number,name,image,cover_date,site_detail_url,description",
+        }
+        cv_response = self.getCVContent(self.api_base_url + "/issues/", params)
+
+        # ------------------------------------
+
+        limit = cv_response["limit"]
+        current_result_count = cv_response["number_of_page_results"]
+        total_result_count = cv_response["number_of_total_results"]
+        # print("total_result_count", total_result_count)
+
+        # print("Found {0} of {1} results".format(cv_response['number_of_page_results'], cv_response['number_of_total_results']))
+        volume_issues_result = cv_response["results"]
+        page = 1
+        offset = 0
+
+        # see if we need to keep asking for more pages...
+        while current_result_count < total_result_count:
+            # print("getting another page of issue results {0} of {1}...".format(current_result_count, total_result_count))
+            page += 1
+            offset += cv_response["number_of_page_results"]
+
+            params["offset"] = offset
+            cv_response = self.getCVContent(self.api_base_url + "/issues/", params)
+
+            volume_issues_result.extend(cv_response["results"])
+            current_result_count += cv_response["number_of_page_results"]
+
+        self.repairUrls(volume_issues_result)
+
+        cvc.add_volume_issues_info(series_id, volume_issues_result)
+
+        return volume_issues_result
+
+    def fetchIssuesByVolumeIssueNumAndYear(self, volume_id_list, issue_number, year):
+        volume_filter = ""
+        for vid in volume_id_list:
+            volume_filter += str(vid) + "|"
+        filter = "volume:{},issue_number:{}".format(volume_filter, issue_number)
+
+        intYear = utils.xlate(year, True)
+        if intYear is not None:
+            filter += ",cover_date:{}-1-1|{}-1-1".format(intYear, intYear + 1)
+
+        params = {
+            "api_key": self.api_key,
+            "format": "json",
+            "field_list": "id,volume,issue_number,name,image,cover_date,site_detail_url,description",
+            "filter": filter,
+        }
+
+        cv_response = self.getCVContent(self.api_base_url + "/issues", params)
+
+        # ------------------------------------
+
+        limit = cv_response["limit"]
+        current_result_count = cv_response["number_of_page_results"]
+        total_result_count = cv_response["number_of_total_results"]
+        # print("total_result_count", total_result_count)
+
+        # print("Found {0} of {1} results\n".format(cv_response['number_of_page_results'], cv_response['number_of_total_results']))
+        filtered_issues_result = cv_response["results"]
+        page = 1
+        offset = 0
+
+        # see if we need to keep asking for more pages...
+        while current_result_count < total_result_count:
+            # print("getting another page of issue results {0} of {1}...\n".format(current_result_count, total_result_count))
+            page += 1
+            offset += cv_response["number_of_page_results"]
+
+            params["offset"] = offset
+            cv_response = self.getCVContent(self.api_base_url + "/issues/", params)
+
+            filtered_issues_result.extend(cv_response["results"])
+            current_result_count += cv_response["number_of_page_results"]
+
+        self.repairUrls(filtered_issues_result)
+
+        return filtered_issues_result
+
+    def fetchIssueData(self, series_id, issue_number, settings):
+
+        volume_results = self.fetchVolumeData(series_id)
+        issues_list_results = self.fetchIssuesByVolume(series_id)
+
+        found = False
+        for record in issues_list_results:
+            if IssueString(issue_number).asString() is None:
+                issue_number = 1
+            if IssueString(record["issue_number"]).asString().lower() == IssueString(issue_number).asString().lower():
+                found = True
+                break
+
+        if found:
+            issue_url = self.api_base_url + "/issue/" + CVTypeID.Issue + "-" + str(record["id"])
+            params = {"api_key": self.api_key, "format": "json"}
+            cv_response = self.getCVContent(issue_url, params)
+            issue_results = cv_response["results"]
+
+        else:
+            return None
+
+        # Now, map the Comic Vine data to generic metadata
+        return self.mapCVDataToMetadata(volume_results, issue_results, settings)
+
+    def fetchIssueDataByIssueID(self, issue_id, settings):
+
+        issue_url = self.api_base_url + "/issue/" + CVTypeID.Issue + "-" + str(issue_id)
+        params = {"api_key": self.api_key, "format": "json"}
+        cv_response = self.getCVContent(issue_url, params)
+
+        issue_results = cv_response["results"]
+
+        volume_results = self.fetchVolumeData(issue_results["volume"]["id"])
+
+        # Now, map the Comic Vine data to generic metadata
+        md = self.mapCVDataToMetadata(volume_results, issue_results, settings)
+        md.isEmpty = False
+        return md
+
+    def mapCVDataToMetadata(self, volume_results, issue_results, settings):
+
+        # Now, map the Comic Vine data to generic metadata
+        metadata = GenericMetadata()
+
+        metadata.series = utils.xlate(issue_results["volume"]["name"])
+        metadata.issue = IssueString(issue_results["issue_number"]).asString()
+        metadata.title = utils.xlate(issue_results["name"])
+
+        if volume_results["publisher"] is not None:
+            metadata.publisher = utils.xlate(volume_results["publisher"]["name"])
+        metadata.day, metadata.month, metadata.year = self.parseDateStr(issue_results["cover_date"])
+
+        metadata.seriesYear = utils.xlate(volume_results["start_year"])
+        metadata.issueCount = utils.xlate(volume_results["count_of_issues"])
+        metadata.comments = self.cleanup_html(issue_results["description"], settings.remove_html_tables)
+        if settings.use_series_start_as_volume:
+            metadata.volume = utils.xlate(volume_results["start_year"])
+
+        metadata.notes = "Tagged with ComicTagger {0} using info from Comic Vine on {1}.  [Issue ID {2}]".format(
+            ctversion.version, datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), issue_results["id"]
+        )
+        # metadata.notes  += issue_results['site_detail_url']
+
+        metadata.webLink = issue_results["site_detail_url"]
+
+        person_credits = issue_results["person_credits"]
+        for person in person_credits:
+            if "role" in person:
+                roles = person["role"].split(",")
+                for role in roles:
+                    # can we determine 'primary' from CV??
+                    metadata.addCredit(person["name"], role.title().strip(), False)
+
+        character_credits = issue_results["character_credits"]
+        character_list = list()
+        for character in character_credits:
+            character_list.append(character["name"])
+        metadata.characters = utils.listToString(character_list)
+
+        team_credits = issue_results["team_credits"]
+        team_list = list()
+        for team in team_credits:
+            team_list.append(team["name"])
+        metadata.teams = utils.listToString(team_list)
+
+        location_credits = issue_results["location_credits"]
+        location_list = list()
+        for location in location_credits:
+            location_list.append(location["name"])
+        metadata.locations = utils.listToString(location_list)
+
+        story_arc_credits = issue_results["story_arc_credits"]
+        arc_list = []
+        for arc in story_arc_credits:
+            arc_list.append(arc["name"])
+        if len(arc_list) > 0:
+            metadata.storyArc = utils.listToString(arc_list)
+
+        return metadata
+
+    def cleanup_html(self, string, remove_html_tables):
+        """
+        converter = html2text.HTML2Text()
+        #converter.emphasis_mark = '*'
+        #converter.ignore_links = True
+        converter.body_width = 0
+
+        print(html2text.html2text(string))
+        return string
+        #return converter.handle(string)
+        """
+
+        if string is None:
+            return ""
+        # find any tables
+        soup = BeautifulSoup(string, "html.parser")
+        tables = soup.findAll("table")
+
+        # remove all newlines first
+        string = string.replace("\n", "")
+
+        # put in our own
+        string = string.replace("<br>", "\n")
+        string = string.replace("</p>", "\n\n")
+        string = string.replace("<h4>", "*")
+        string = string.replace("</h4>", "*\n")
+
+        # remove the tables
+        p = re.compile(r"<table[^<]*?>.*?<\/table>")
+        if remove_html_tables:
+            string = p.sub("", string)
+            string = string.replace("*List of covers and their creators:*", "")
+        else:
+            string = p.sub("{}", string)
+
+        # now strip all other tags
+        p = re.compile(r"<[^<]*?>")
+        newstring = p.sub("", string)
+
+        newstring = newstring.replace("&nbsp;", " ")
+        newstring = newstring.replace("&amp;", "&")
+
+        newstring = newstring.strip()
+
+        if not remove_html_tables:
+            # now rebuild the tables into text from BSoup
+            try:
+                table_strings = []
+                for table in tables:
+                    rows = []
+                    hdrs = []
+                    col_widths = []
+                    for hdr in table.findAll("th"):
+                        item = hdr.string.strip()
+                        hdrs.append(item)
+                        col_widths.append(len(item))
+                    rows.append(hdrs)
+
+                    for row in table.findAll("tr"):
+                        cols = []
+                        col = row.findAll("td")
+                        i = 0
+                        for c in col:
+                            item = c.string.strip()
+                            cols.append(item)
+                            if len(item) > col_widths[i]:
+                                col_widths[i] = len(item)
+                            i += 1
+                        if len(cols) != 0:
+                            rows.append(cols)
+                    # now we have the data, make it into text
+                    fmtstr = ""
+                    for w in col_widths:
+                        fmtstr += " {{:{}}}|".format(w + 1)
+                    width = sum(col_widths) + len(col_widths) * 2
+                    print("width=", width)
+                    table_text = ""
+                    counter = 0
+                    for row in rows:
+                        table_text += fmtstr.format(*row) + "\n"
+                        if counter == 0 and len(hdrs) != 0:
+                            table_text += "-" * width + "\n"
+                        counter += 1
+
+                    table_strings.append(table_text)
+
+                newstring = newstring.format(*table_strings)
+            except:
+                # we caught an error rebuilding the table.
+                # just bail and remove the formatting
+                print("table parse error")
+                newstring.replace("{}", "")
+
+        return newstring
+
+    def fetchIssueDate(self, issue_id):
+        details = self.fetchIssueSelectDetails(issue_id)
+        day, month, year = self.parseDateStr(details["cover_date"])
+        return month, year
+
+    def fetchIssueCoverURLs(self, issue_id):
+        details = self.fetchIssueSelectDetails(issue_id)
+        return details["image_url"], details["thumb_image_url"]
+
+    def fetchIssuePageURL(self, issue_id):
+        details = self.fetchIssueSelectDetails(issue_id)
+        return details["site_detail_url"]
+
+    def fetchIssueSelectDetails(self, issue_id):
+
+        # cached_image_url,cached_thumb_url,cached_month,cached_year = self.fetchCachedIssueSelectDetails(issue_id)
+        cached_details = self.fetchCachedIssueSelectDetails(issue_id)
+        if cached_details["image_url"] is not None:
+            return cached_details
+
+        issue_url = self.api_base_url + "/issue/" + CVTypeID.Issue + "-" + str(issue_id)
+
+        params = {"api_key": self.api_key, "format": "json", "field_list": "image,cover_date,site_detail_url"}
+
+        cv_response = self.getCVContent(issue_url, params)
+
+        details = dict()
+        details["image_url"] = None
+        details["thumb_image_url"] = None
+        details["cover_date"] = None
+        details["site_detail_url"] = None
+
+        details["image_url"] = cv_response["results"]["image"]["super_url"]
+        details["thumb_image_url"] = cv_response["results"]["image"]["thumb_url"]
+        details["cover_date"] = cv_response["results"]["cover_date"]
+        details["site_detail_url"] = cv_response["results"]["site_detail_url"]
+
+        if details["image_url"] is not None:
+            self.cacheIssueSelectDetails(
+                issue_id, details["image_url"], details["thumb_image_url"], details["cover_date"], details["site_detail_url"]
+            )
+        # print(details['site_detail_url'])
+        return details
+
+    def fetchCachedIssueSelectDetails(self, issue_id):
+
+        # before we search online, look in our cache, since we might already
+        # have this info
+        cvc = ComicVineCacher()
+        return cvc.get_issue_select_details(issue_id)
+
+    def cacheIssueSelectDetails(self, issue_id, image_url, thumb_url, cover_date, page_url):
+        cvc = ComicVineCacher()
+        cvc.add_issue_select_details(issue_id, image_url, thumb_url, cover_date, page_url)
+
+    def fetchAlternateCoverURLs(self, issue_id, issue_page_url):
+        url_list = self.fetchCachedAlternateCoverURLs(issue_id)
+        if url_list is not None:
+            return url_list
+
+        # scrape the CV issue page URL to get the alternate cover URLs
+        content = requests.get(issue_page_url, headers={"user-agent": "comictagger/" + _version.version}).text
+        alt_cover_url_list = self.parseOutAltCoverUrls(content)
+
+        # cache this alt cover URL list
+        self.cacheAlternateCoverURLs(issue_id, alt_cover_url_list)
+
+        return alt_cover_url_list
+
+    def parseOutAltCoverUrls(self, page_html):
+        soup = BeautifulSoup(page_html, "html.parser")
+
+        alt_cover_url_list = []
+
+        # Using knowledge of the layout of the Comic Vine issue page here:
+        # look for the divs that are in the classes 'imgboxart' and
+        # 'issue-cover'
+        div_list = soup.find_all("div")
+        covers_found = 0
+        for d in div_list:
+            if "class" in d.attrs:
+                c = d["class"]
+                if "imgboxart" in c and "issue-cover" in c and d.img["src"].startswith("http"):
+
+                    covers_found += 1
+                    if covers_found != 1:
+                        alt_cover_url_list.append(d.img["src"])
+
+        return alt_cover_url_list
+
+    def fetchCachedAlternateCoverURLs(self, issue_id):
+
+        # before we search online, look in our cache, since we might already
+        # have this info
+        cvc = ComicVineCacher()
+        url_list = cvc.get_alt_covers(issue_id)
+        if url_list is not None:
+            return url_list
+        else:
+            return None
+
+    def cacheAlternateCoverURLs(self, issue_id, url_list):
+        cvc = ComicVineCacher()
+        cvc.add_alt_covers(issue_id, url_list)
+
+    # -------------------------------------------------------------------------
+    urlFetchComplete = pyqtSignal(str, str, int)
+
+    def asyncFetchIssueCoverURLs(self, issue_id):
+
+        self.issue_id = issue_id
+        details = self.fetchCachedIssueSelectDetails(issue_id)
+        if details["image_url"] is not None:
+            self.urlFetchComplete.emit(details["image_url"], details["thumb_image_url"], self.issue_id)
+            return
+
+        issue_url = (
+            self.api_base_url
+            + "/issue/"
+            + CVTypeID.Issue
+            + "-"
+            + str(issue_id)
+            + "/?api_key="
+            + self.api_key
+            + "&format=json&field_list=image,cover_date,site_detail_url"
+        )
+        self.nam = QNetworkAccessManager()
+        self.nam.finished.connect(self.asyncFetchIssueCoverURLComplete)
+        self.nam.get(QNetworkRequest(QUrl(issue_url)))
+
+    def asyncFetchIssueCoverURLComplete(self, reply):
+
+        # read in the response
+        data = reply.readAll()
+
+        try:
+            cv_response = json.loads(bytes(data))
+        except Exception as e:
+            print("Comic Vine query failed to get JSON data", file=sys.stderr)
+            print(str(data), file=sys.stderr)
+            return
+
+        if cv_response["status_code"] != 1:
+            print("Comic Vine query failed with error:  [{0}]. ".format(cv_response["error"]), file=sys.stderr)
+            return
+
+        image_url = cv_response["results"]["image"]["super_url"]
+        thumb_url = cv_response["results"]["image"]["thumb_url"]
+        cover_date = cv_response["results"]["cover_date"]
+        page_url = cv_response["results"]["site_detail_url"]
+
+        self.cacheIssueSelectDetails(self.issue_id, image_url, thumb_url, cover_date, page_url)
+
+        self.urlFetchComplete.emit(image_url, thumb_url, self.issue_id)
+
+    altUrlListFetchComplete = pyqtSignal(list, int)
+
+    def asyncFetchAlternateCoverURLs(self, issue_id, issue_page_url):
+        # This async version requires the issue page url to be provided!
+        self.issue_id = issue_id
+        url_list = self.fetchCachedAlternateCoverURLs(issue_id)
+        if url_list is not None:
+            self.altUrlListFetchComplete.emit(url_list, int(self.issue_id))
+            return
+
+        self.nam = QNetworkAccessManager()
+        self.nam.finished.connect(self.asyncFetchAlternateCoverURLsComplete)
+        self.nam.get(QNetworkRequest(QUrl(str(issue_page_url))))
+
+    def asyncFetchAlternateCoverURLsComplete(self, reply):
+        # read in the response
+        html = str(reply.readAll())
+        alt_cover_url_list = self.parseOutAltCoverUrls(html)
+
+        # cache this alt cover URL list
+        self.cacheAlternateCoverURLs(self.issue_id, alt_cover_url_list)
+
+        self.altUrlListFetchComplete.emit(alt_cover_url_list, int(self.issue_id))
+
+    def repairUrls(self, issue_list):
+        # make sure there are URLs for the image fields
+        for issue in issue_list:
+            if issue["image"] is None:
+                issue["image"] = dict()
+                issue["image"]["super_url"] = ComicVineTalker.logo_url
+                issue["image"]["thumb_url"] = ComicVineTalker.logo_url

comictaggerlib/coverimagewidget.py

@@ -3,209 +3,204 @@
 Display cover images from either a local archive, or from Comic Vine.
 TODO: This should be re-factored using subclasses!
 """
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import logging
-import pathlib
+from PyQt5 import uic
+from PyQt5.QtCore import *
+from PyQt5.QtGui import *
+from PyQt5.QtWidgets import *
 
-from PyQt5 import QtCore, QtGui, QtWidgets, uic
+from comictaggerlib.ui.qtutils import getQImageFromData, reduceWidgetFontSize
 
-from comicapi.comicarchive import ComicArchive
-from comictaggerlib.graphics import graphics_path
-from comictaggerlib.imagefetcher import ImageFetcher
-from comictaggerlib.imagepopup import ImagePopup
-from comictaggerlib.pageloader import PageLoader
-from comictaggerlib.ui import ui_path
-from comictaggerlib.ui.qtutils import get_qimage_from_data, reduce_widget_font_size
-from comictalker.comictalker import ComicTalker
-
-logger = logging.getLogger(__name__)
+from .comicvinetalker import ComicVineTalker, ComicVineTalkerException
+from .imagefetcher import ImageFetcher
+from .imagepopup import ImagePopup
+from .pageloader import PageLoader
+from .settings import ComicTaggerSettings
 
 
-def clickable(widget: QtWidgets.QWidget) -> QtCore.pyqtBoundSignal:
-    """Allow a label to be clickable"""
+def clickable(widget):
+    """# Allow a label to be clickable"""
 
-    class Filter(QtCore.QObject):
-        dblclicked = QtCore.pyqtSignal()
+    class Filter(QObject):
+
+        dblclicked = pyqtSignal()
+
+        def eventFilter(self, obj, event):
 
-        def eventFilter(self, obj: QtCore.QObject, event: QtCore.QEvent) -> bool:
             if obj == widget:
-                if event.type() == QtCore.QEvent.Type.MouseButtonDblClick:
+                if event.type() == QEvent.MouseButtonDblClick:
                     self.dblclicked.emit()
                     return True
+
             return False
 
-    flt = Filter(widget)
-    widget.installEventFilter(flt)
-    return flt.dblclicked
+    filter = Filter(widget)
+    widget.installEventFilter(filter)
+    return filter.dblclicked
 
 
-class CoverImageWidget(QtWidgets.QWidget):
+class CoverImageWidget(QWidget):
+
     ArchiveMode = 0
     AltCoverMode = 1
     URLMode = 1
     DataMode = 3
 
-    image_fetch_complete = QtCore.pyqtSignal(QtCore.QByteArray)
+    def __init__(self, parent, mode, expand_on_click=True):
+        super(CoverImageWidget, self).__init__(parent)
 
-    def __init__(
-        self,
-        parent: QtWidgets.QWidget,
-        mode: int,
-        cache_folder: pathlib.Path | None,
-        talker: ComicTalker | None,
-        expand_on_click: bool = True,
-    ) -> None:
-        super().__init__(parent)
+        uic.loadUi(ComicTaggerSettings.getUIFile("coverimagewidget.ui"), self)
 
-        if mode not in (self.AltCoverMode, self.URLMode) or cache_folder is None:
-            self.cover_fetcher = None
-            self.talker = None
-        else:
-            self.cover_fetcher = ImageFetcher(cache_folder)
-            self.talker = None
-        uic.loadUi(ui_path / "coverimagewidget.ui", self)
+        reduceWidgetFontSize(self.label)
 
-        reduce_widget_font_size(self.label)
-
-        self.cache_folder = cache_folder
-        self.mode: int = mode
-        self.page_loader: PageLoader | None = None
+        self.mode = mode
+        self.comicVine = ComicVineTalker()
+        self.page_loader = None
         self.showControls = True
 
-        self.current_pixmap = QtGui.QPixmap()
+        self.btnLeft.setIcon(QIcon(ComicTaggerSettings.getGraphic("left.png")))
+        self.btnRight.setIcon(QIcon(ComicTaggerSettings.getGraphic("right.png")))
 
-        self.comic_archive: ComicArchive | None = None
-        self.issue_id: str = ""
-        self.issue_url: str | None = None
-        self.url_list: list[str] = []
-        if self.page_loader is not None:
-            self.page_loader.abandoned = True
-        self.page_loader = None
-        self.imageIndex = -1
-        self.imageCount = 1
-        self.imageData = b""
-
-        self.btnLeft.setIcon(QtGui.QIcon(str(graphics_path / "left.png")))
-        self.btnRight.setIcon(QtGui.QIcon(str(graphics_path / "right.png")))
-
-        self.btnLeft.clicked.connect(self.decrement_image)
-        self.btnRight.clicked.connect(self.increment_image)
-        self.image_fetch_complete.connect(self.cover_remote_fetch_complete)
+        self.btnLeft.clicked.connect(self.decrementImage)
+        self.btnRight.clicked.connect(self.incrementImage)
+        self.resetWidget()
         if expand_on_click:
-            clickable(self.lblImage).connect(self.show_popup)
+            clickable(self.lblImage).connect(self.showPopup)
         else:
             self.lblImage.setToolTip("")
 
-        self.update_content()
+        self.updateContent()
 
-    def reset_widget(self) -> None:
+    def resetWidget(self):
         self.comic_archive = None
-        self.issue_id = ""
-        self.issue_url = None
+        self.issue_id = None
+        self.comicVine = None
+        self.cover_fetcher = None
         self.url_list = []
         if self.page_loader is not None:
             self.page_loader.abandoned = True
         self.page_loader = None
         self.imageIndex = -1
         self.imageCount = 1
-        self.imageData = b""
+        self.imageData = None
 
-    def clear(self) -> None:
-        self.reset_widget()
-        self.update_content()
+    def clear(self):
+        self.resetWidget()
+        self.updateContent()
 
-    def increment_image(self) -> None:
+    def incrementImage(self):
         self.imageIndex += 1
         if self.imageIndex == self.imageCount:
             self.imageIndex = 0
-        self.update_content()
+        self.updateContent()
 
-    def decrement_image(self) -> None:
+    def decrementImage(self):
         self.imageIndex -= 1
         if self.imageIndex == -1:
             self.imageIndex = self.imageCount - 1
-        self.update_content()
+        self.updateContent()
 
-    def set_archive(self, ca: ComicArchive, page: int = 0) -> None:
+    def setArchive(self, ca, page=0):
         if self.mode == CoverImageWidget.ArchiveMode:
-            self.reset_widget()
+            self.resetWidget()
             self.comic_archive = ca
             self.imageIndex = page
-            self.imageCount = ca.get_number_of_pages()
-            self.update_content()
+            self.imageCount = ca.getNumberOfPages()
+            self.updateContent()
 
-    def set_url(self, url: str) -> None:
+    def setURL(self, url):
         if self.mode == CoverImageWidget.URLMode:
-            self.reset_widget()
-            self.update_content()
+            self.resetWidget()
+            self.updateContent()
 
             self.url_list = [url]
             self.imageIndex = 0
             self.imageCount = 1
-            self.update_content()
+            self.updateContent()
 
-    def set_issue_details(self, issue_id: str, url_list: list[str]) -> None:
+    def setIssueID(self, issue_id):
         if self.mode == CoverImageWidget.AltCoverMode:
-            self.reset_widget()
-            self.update_content()
+            self.resetWidget()
+            self.updateContent()
+
             self.issue_id = issue_id
 
-            self.set_url_list(url_list)
+            self.comicVine = ComicVineTalker()
+            self.comicVine.urlFetchComplete.connect(self.primaryUrlFetchComplete)
+            self.comicVine.asyncFetchIssueCoverURLs(int(self.issue_id))
 
-    def set_image_data(self, image_data: bytes) -> None:
+    def setImageData(self, image_data):
         if self.mode == CoverImageWidget.DataMode:
-            self.reset_widget()
+            self.resetWidget()
 
-            if image_data:
+            if image_data is None:
+                self.imageIndex = -1
+            else:
                 self.imageIndex = 0
                 self.imageData = image_data
-            else:
-                self.imageIndex = -1
 
-            self.update_content()
+            self.updateContent()
 
-    def set_url_list(self, url_list: list[str]) -> None:
-        self.url_list = url_list
+    def primaryUrlFetchComplete(self, primary_url, thumb_url, issue_id):
+        self.url_list.append(str(primary_url))
         self.imageIndex = 0
         self.imageCount = len(self.url_list)
-        self.update_content()
-        self.update_controls()
+        self.updateContent()
 
-    def set_page(self, pagenum: int) -> None:
+        # defer the alt cover search
+        QTimer.singleShot(1, self.startAltCoverSearch)
+
+    def startAltCoverSearch(self):
+
+        # now we need to get the list of alt cover URLs
+        self.label.setText("Searching for alt. covers...")
+
+        # page URL should already be cached, so no need to defer
+        self.comicVine = ComicVineTalker()
+        issue_page_url = self.comicVine.fetchIssuePageURL(self.issue_id)
+        self.comicVine.altUrlListFetchComplete.connect(self.altCoverUrlListFetchComplete)
+        self.comicVine.asyncFetchAlternateCoverURLs(int(self.issue_id), issue_page_url)
+
+    def altCoverUrlListFetchComplete(self, url_list, issue_id):
+        if len(url_list) > 0:
+            self.url_list.extend(url_list)
+            self.imageCount = len(self.url_list)
+        self.updateControls()
+
+    def setPage(self, pagenum):
         if self.mode == CoverImageWidget.ArchiveMode:
             self.imageIndex = pagenum
-            self.update_content()
+            self.updateContent()
 
-    def update_content(self) -> None:
-        self.update_image()
-        self.update_controls()
+    def updateContent(self):
+        self.updateImage()
+        self.updateControls()
 
-    def update_image(self) -> None:
+    def updateImage(self):
         if self.imageIndex == -1:
-            self.load_default()
+            self.loadDefault()
         elif self.mode in [CoverImageWidget.AltCoverMode, CoverImageWidget.URLMode]:
-            self.load_url()
+            self.loadURL()
         elif self.mode == CoverImageWidget.DataMode:
-            self.cover_remote_fetch_complete(self.imageData)
+            self.coverRemoteFetchComplete(self.imageData, 0)
         else:
-            self.load_page()
+            self.loadPage()
 
-    def update_controls(self) -> None:
+    def updateControls(self):
         if not self.showControls or self.mode == CoverImageWidget.DataMode:
             self.btnLeft.hide()
             self.btnRight.hide()
@@ -226,48 +221,62 @@ class CoverImageWidget(QtWidgets.QWidget):
         if self.imageIndex == -1 or self.imageCount == 1:
             self.label.setText("")
         elif self.mode == CoverImageWidget.AltCoverMode:
-            self.label.setText(f"Cover {self.imageIndex + 1} (of {self.imageCount})")
+            self.label.setText("Cover {0} (of {1})".format(self.imageIndex + 1, self.imageCount))
         else:
-            self.label.setText(f"Page {self.imageIndex + 1} (of {self.imageCount})")
+            self.label.setText("Page {0} (of {1})".format(self.imageIndex + 1, self.imageCount))
 
-    def load_url(self) -> None:
-        assert isinstance(self.cache_folder, pathlib.Path)
-        self.load_default()
-        self.cover_fetcher = ImageFetcher(self.cache_folder)
-        ImageFetcher.image_fetch_complete = self.image_fetch_complete.emit
+    def loadURL(self):
+        self.loadDefault()
+        self.cover_fetcher = ImageFetcher()
+        self.cover_fetcher.fetchComplete.connect(self.coverRemoteFetchComplete)
         self.cover_fetcher.fetch(self.url_list[self.imageIndex])
+        # print("ATB cover fetch started...")
 
     # called when the image is done loading from internet
-    def cover_remote_fetch_complete(self, image_data: bytes) -> None:
-        img = get_qimage_from_data(image_data)
-        self.current_pixmap = QtGui.QPixmap.fromImage(img)
-        self.set_display_pixmap()
+    def coverRemoteFetchComplete(self, image_data, issue_id):
+        img = getQImageFromData(image_data)
+        self.current_pixmap = QPixmap(img)
+        self.setDisplayPixmap(0, 0)
+        # print("ATB cover fetch complete!")
 
-    def load_page(self) -> None:
+    def loadPage(self):
         if self.comic_archive is not None:
             if self.page_loader is not None:
                 self.page_loader.abandoned = True
             self.page_loader = PageLoader(self.comic_archive, self.imageIndex)
-            self.page_loader.loadComplete.connect(self.page_load_complete)
+            self.page_loader.loadComplete.connect(self.pageLoadComplete)
             self.page_loader.start()
 
-    def page_load_complete(self, image_data: bytes) -> None:
-        img = get_qimage_from_data(image_data)
-        self.current_pixmap = QtGui.QPixmap.fromImage(img)
-        self.set_display_pixmap()
+    def pageLoadComplete(self, img):
+        self.current_pixmap = QPixmap(img)
+        self.setDisplayPixmap(0, 0)
         self.page_loader = None
 
-    def load_default(self) -> None:
-        self.current_pixmap = QtGui.QPixmap(str(graphics_path / "nocover.png"))
-        self.set_display_pixmap()
+    def loadDefault(self):
+        self.current_pixmap = QPixmap(ComicTaggerSettings.getGraphic("nocover.png"))
+        # print("loadDefault called")
+        self.setDisplayPixmap(0, 0)
 
-    def resizeEvent(self, resize_event: QtGui.QResizeEvent) -> None:
+    def resizeEvent(self, resize_event):
         if self.current_pixmap is not None:
-            self.set_display_pixmap()
+            delta_w = resize_event.size().width() - resize_event.oldSize().width()
+            delta_h = resize_event.size().height() - resize_event.oldSize().height()
+            # print "ATB resizeEvent deltas", resize_event.size().width(),
+            # resize_event.size().height()
+            self.setDisplayPixmap(delta_w, delta_h)
 
-    def set_display_pixmap(self) -> None:
+    def setDisplayPixmap(self, delta_w, delta_h):
         """The deltas let us know what the new width and height of the label will be"""
 
+        # new_h = self.frame.height() + delta_h
+        # new_w = self.frame.width() + delta_w
+        # print "ATB setDisplayPixmap deltas", delta_w , delta_h
+        # print "ATB self.frame", self.frame.width(), self.frame.height()
+        # print "ATB self.", self.width(), self.height()
+
+        # frame_w = new_w
+        # frame_h = new_h
+
         new_h = self.frame.height()
         new_w = self.frame.width()
         frame_w = self.frame.width()
@@ -276,20 +285,24 @@ class CoverImageWidget(QtWidgets.QWidget):
         new_h -= 4
         new_w -= 4
 
-        new_h = max(new_h, 0)
-        new_w = max(new_w, 0)
+        if new_h < 0:
+            new_h = 0
+        if new_w < 0:
+            new_w = 0
+
+        # print "ATB setDisplayPixmap deltas", delta_w , delta_h
+        # print "ATB self.frame", frame_w, frame_h
+        # print "ATB new size", new_w, new_h
 
         # scale the pixmap to fit in the frame
-        scaled_pixmap = self.current_pixmap.scaled(
-            new_w, new_h, QtCore.Qt.AspectRatioMode.KeepAspectRatio, QtCore.Qt.SmoothTransformation
-        )
+        scaled_pixmap = self.current_pixmap.scaled(new_w, new_h, Qt.KeepAspectRatio, Qt.SmoothTransformation)
         self.lblImage.setPixmap(scaled_pixmap)
 
         # move and resize the label to be centered in the fame
         img_w = scaled_pixmap.width()
         img_h = scaled_pixmap.height()
         self.lblImage.resize(img_w, img_h)
-        self.lblImage.move(int((frame_w - img_w) / 2), int((frame_h - img_h) / 2))
+        self.lblImage.move((frame_w - img_w) / 2, (frame_h - img_h) / 2)
 
-    def show_popup(self) -> None:
-        ImagePopup(self, self.current_pixmap)
+    def showPopup(self):
+        self.popup = ImagePopup(self, self.current_pixmap)

comictaggerlib/crediteditorwindow.py

@@ -1,38 +1,33 @@
 """A PyQT4 dialog to edit credits"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import logging
-from typing import Any
+from PyQt5 import QtCore, QtGui, QtWidgets, uic
 
-from PyQt5 import QtWidgets, uic
-
-from comictaggerlib.ui import ui_path
-
-logger = logging.getLogger(__name__)
+from .settings import ComicTaggerSettings
 
 
 class CreditEditorWindow(QtWidgets.QDialog):
+
     ModeEdit = 0
     ModeNew = 1
 
-    def __init__(self, parent: QtWidgets.QWidget, mode: int, role: str, name: str, primary: bool) -> None:
-        super().__init__(parent)
+    def __init__(self, parent, mode, role, name, primary):
+        super(CreditEditorWindow, self).__init__(parent)
 
-        uic.loadUi(ui_path / "crediteditorwindow.ui", self)
+        uic.loadUi(ComicTaggerSettings.getUIFile("crediteditorwindow.ui"), self)
 
         self.mode = mode
 
@@ -64,33 +59,34 @@ class CreditEditorWindow(QtWidgets.QDialog):
             else:
                 self.cbRole.setCurrentIndex(i)
 
-        self.cbPrimary.setChecked(primary)
+        if primary:
+            self.cbPrimary.setCheckState(QtCore.Qt.Checked)
 
-        self.cbRole.currentIndexChanged.connect(self.role_changed)
-        self.cbRole.editTextChanged.connect(self.role_changed)
+        self.cbRole.currentIndexChanged.connect(self.roleChanged)
+        self.cbRole.editTextChanged.connect(self.roleChanged)
 
-        self.update_primary_button()
+        self.updatePrimaryButton()
 
-    def update_primary_button(self) -> None:
-        enabled = self.current_role_can_be_primary()
+    def updatePrimaryButton(self):
+        enabled = self.currentRoleCanBePrimary()
         self.cbPrimary.setEnabled(enabled)
 
-    def current_role_can_be_primary(self) -> bool:
+    def currentRoleCanBePrimary(self):
         role = self.cbRole.currentText()
-        if role.casefold() in ("artist", "writer"):
+        if str(role).lower() == "writer" or str(role).lower() == "artist":
             return True
+        else:
+            return False
 
-        return False
+    def roleChanged(self, s):
+        self.updatePrimaryButton()
 
-    def role_changed(self, s: Any) -> None:
-        self.update_primary_button()
-
-    def get_credits(self) -> tuple[str, str, bool]:
-        primary = self.current_role_can_be_primary() and self.cbPrimary.isChecked()
+    def getCredits(self):
+        primary = self.currentRoleCanBePrimary() and self.cbPrimary.isChecked()
         return self.cbRole.currentText(), self.leName.text(), primary
 
-    def accept(self) -> None:
+    def accept(self):
         if self.cbRole.currentText() == "" or self.leName.text() == "":
-            QtWidgets.QMessageBox.warning(self, "Whoops", "You need to enter both role and name for a credit.")
+            QtWidgets.QMessageBox.warning(self, self.tr("Whoops"), self.tr("You need to enter both role and name for a credit."))
         else:
             QtWidgets.QDialog.accept(self)

comictaggerlib/ctsettings/__init__.py

@@ -1,24 +0,0 @@
-from __future__ import annotations
-
-from comictaggerlib.ctsettings.commandline import (
-    initial_commandline_parser,
-    register_commandline_settings,
-    validate_commandline_settings,
-)
-from comictaggerlib.ctsettings.file import register_file_settings, validate_file_settings
-from comictaggerlib.ctsettings.plugin import register_plugin_settings, validate_plugin_settings
-from comictaggerlib.ctsettings.types import ComicTaggerPaths
-from comictalker import ComicTalker
-
-talkers: dict[str, ComicTalker] = {}
-
-__all__ = [
-    "initial_commandline_parser",
-    "register_commandline_settings",
-    "register_file_settings",
-    "register_plugin_settings",
-    "validate_commandline_settings",
-    "validate_file_settings",
-    "validate_plugin_settings",
-    "ComicTaggerPaths",
-]

comictaggerlib/ctsettings/commandline.py

@@ -1,306 +0,0 @@
-"""CLI settings for ComicTagger"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-from __future__ import annotations
-
-import argparse
-import logging
-import os
-import platform
-
-import settngs
-
-from comicapi import utils
-from comicapi.genericmetadata import GenericMetadata
-from comictaggerlib import ctversion
-from comictaggerlib.ctsettings.types import ComicTaggerPaths, metadata_type, parse_metadata_from_string
-
-logger = logging.getLogger(__name__)
-
-
-def initial_commandline_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(add_help=False)
-    # Ensure this stays up to date with register_settings
-    parser.add_argument(
-        "--config",
-        help="Config directory defaults to ~/.ComicTagger\non Linux/Mac and %%APPDATA%% on Windows\n",
-        type=ComicTaggerPaths,
-        default=ComicTaggerPaths(),
-    )
-    parser.add_argument("-v", "--verbose", action="count", default=0, help="Be noisy when doing what it does.")
-    return parser
-
-
-def register_settings(parser: settngs.Manager) -> None:
-    parser.add_setting(
-        "--config",
-        help="Config directory defaults to ~/.Config/ComicTagger\non Linux, ~/Library/Application Support/ComicTagger on Mac and %%APPDATA%%\\ComicTagger on Windows\n",
-        type=ComicTaggerPaths,
-        default=ComicTaggerPaths(),
-        file=False,
-    )
-    parser.add_setting(
-        "-v",
-        "--verbose",
-        action="count",
-        default=0,
-        help="Be noisy when doing what it does.",
-        file=False,
-    )
-    parser.add_setting(
-        "--abort-on-conflict",
-        action="store_true",
-        help="""Don't export to zip if intended new filename\nexists (otherwise, creates a new unique filename).\n\n""",
-        file=False,
-    )
-    parser.add_setting(
-        "--delete-original",
-        action="store_true",
-        dest="delete_after_zip_export",
-        help="""Delete original archive after successful\nexport to Zip. (only relevant for -e)""",
-        file=False,
-    )
-    parser.add_setting(
-        "-f",
-        "--parse-filename",
-        "--parsefilename",
-        action="store_true",
-        help="""Parse the filename to get some info,\nspecifically series name, issue number,\nvolume, and publication year.\n\n""",
-        file=False,
-    )
-    parser.add_setting(
-        "--id",
-        dest="issue_id",
-        type=int,
-        help="""Use the issue ID when searching online.\nOverrides all other metadata.\n\n""",
-        file=False,
-    )
-    parser.add_setting(
-        "-o",
-        "--online",
-        action="store_true",
-        help="""Search online and attempt to identify file\nusing existing metadata and images in archive.\nMay be used in conjunction with -f and -m.\n\n""",
-        file=False,
-    )
-    parser.add_setting(
-        "-m",
-        "--metadata",
-        default=GenericMetadata(),
-        type=parse_metadata_from_string,
-        help="""Explicitly define, as a list, some tags to be used.  e.g.:\n"series=Plastic Man, publisher=Quality Comics"\n"series=Kickers^, Inc., issue=1, year=1986"\nName-Value pairs are comma separated. Use a\n"^" to escape an "=" or a ",", as shown in\nthe example above.  Some names that can be\nused: series, issue, issue_count, year,\npublisher, title\n\n""",
-        file=False,
-    )
-    parser.add_setting(
-        "-i",
-        "--interactive",
-        action="store_true",
-        help="""Interactively query the user when there are\nmultiple matches for an online search.\n\n""",
-        file=False,
-    )
-    parser.add_setting(
-        "--abort",
-        dest="abort_on_low_confidence",
-        action=argparse.BooleanOptionalAction,
-        default=True,
-        help="""Abort save operation when online match\nis of low confidence.\n\n""",
-        file=False,
-    )
-    parser.add_setting(
-        "--summary",
-        default=True,
-        action=argparse.BooleanOptionalAction,
-        help="Show the summary after a save operation.\n\n",
-        file=False,
-    )
-    parser.add_setting(
-        "--raw",
-        action="store_true",
-        help="""With -p, will print out the raw tag block(s)\nfrom the file.\n""",
-        file=False,
-    )
-    parser.add_setting(
-        "-R",
-        "--recursive",
-        action="store_true",
-        help="Recursively include files in sub-folders.",
-        file=False,
-    )
-    parser.add_setting(
-        "-S",
-        "--script",
-        help="""Run an "add-on" python script that uses the\nComicTagger library for custom processing.\nScript arguments can follow the script name.\n\n""",
-        file=False,
-    )
-    parser.add_setting(
-        "--split-words",
-        action="store_true",
-        help="""Splits words before parsing the filename.\ne.g. 'judgedredd' to 'judge dredd'\n\n""",
-        file=False,
-    )
-    parser.add_setting(
-        "-n",
-        "--dryrun",
-        action="store_true",
-        help="Don't actually modify file (only relevant for -d, -s, or -r).\n\n",
-        file=False,
-    )
-    parser.add_setting("--darkmode", action="store_true", help="Windows only. Force a dark pallet", file=False)
-    parser.add_setting("-g", "--glob", action="store_true", help="Windows only. Enable globbing", file=False)
-    parser.add_setting("--quiet", "-q", action="store_true", help="Don't say much (for print mode).", file=False)
-
-    parser.add_setting(
-        "-t",
-        "--type",
-        metavar="{CR,CBL,COMET}",
-        default=[],
-        type=metadata_type,
-        help="""Specify TYPE as either CR, CBL or COMET\n(as either ComicRack, ComicBookLover,\nor CoMet style tags, respectively).\nUse commas for multiple types.\nFor searching the metadata will use the first listed:\neg '-t cbl,cr' with no CBL tags, CR will be used if they exist\n\n""",
-        file=False,
-    )
-    parser.add_setting(
-        "--overwrite",
-        dest="overwrite",
-        action=argparse.BooleanOptionalAction,
-        default=True,
-        help="""Apply metadata to already tagged archives (relevant for -s or -c).""",
-        file=False,
-    )
-    parser.add_setting("files", nargs="*", file=False)
-
-
-def register_commands(parser: settngs.Manager) -> None:
-    parser.add_setting("--version", action="store_true", help="Display version.", file=False)
-
-    parser.add_setting(
-        "-p",
-        "--print",
-        action="store_true",
-        help="""Print out tag info from file. Specify type\n(via -t) to get only info of that tag type.\n\n""",
-        file=False,
-    )
-    parser.add_setting(
-        "-d",
-        "--delete",
-        action="store_true",
-        help="Deletes the tag block of specified type (via -t).\n",
-        file=False,
-    )
-    parser.add_setting(
-        "-c",
-        "--copy",
-        type=metadata_type,
-        metavar="{CR,CBL,COMET}",
-        help="Copy the specified source tag block to\ndestination style specified via -t\n(potentially lossy operation).\n\n",
-        file=False,
-    )
-    parser.add_setting(
-        "-s",
-        "--save",
-        action="store_true",
-        help="Save out tags as specified type (via -t).\nMust specify also at least -o, -f, or -m.\n\n",
-        file=False,
-    )
-    parser.add_setting(
-        "-r",
-        "--rename",
-        action="store_true",
-        help="Rename the file based on specified tag style.",
-        file=False,
-    )
-    parser.add_setting(
-        "-e",
-        "--export-to-zip",
-        action="store_true",
-        help="Export RAR archive to Zip format.",
-        file=False,
-    )
-    parser.add_setting(
-        "--only-set-cv-key",
-        action="store_true",
-        help="Only set the Comic Vine API key and quit.\n\n",
-        file=False,
-    )
-
-
-def register_commandline_settings(parser: settngs.Manager) -> None:
-    parser.add_group("commands", register_commands, True)
-    parser.add_persistent_group("runtime", register_settings)
-
-
-def validate_commandline_settings(
-    config: settngs.Config[settngs.Namespace], parser: settngs.Manager
-) -> settngs.Config[settngs.Namespace]:
-    if config[0].commands_version:
-        parser.exit(
-            status=1,
-            message=f"ComicTagger {ctversion.version}:  Copyright (c) 2012-2022 ComicTagger Team\n"
-            "Distributed under Apache License 2.0 (http://www.apache.org/licenses/LICENSE-2.0)\n",
-        )
-
-    config[0].runtime_no_gui = any(
-        [
-            config[0].commands_print,
-            config[0].commands_delete,
-            config[0].commands_save,
-            config[0].commands_copy,
-            config[0].commands_rename,
-            config[0].commands_export_to_zip,
-            config[0].commands_only_set_cv_key,
-        ]
-    )
-
-    if platform.system() == "Windows" and config[0].runtime_glob:
-        # no globbing on windows shell, so do it for them
-        import glob
-
-        globs = config[0].runtime_files
-        config[0].runtime_files = []
-        for item in globs:
-            config[0].runtime_files.extend(glob.glob(item))
-
-    if not config[0].commands_only_set_cv_key and config[0].runtime_no_gui and not config[0].runtime_files:
-        parser.exit(message="Command requires at least one filename!\n", status=1)
-
-    if config[0].commands_delete and not config[0].runtime_type:
-        parser.exit(message="Please specify the type to delete with -t\n", status=1)
-
-    if config[0].commands_save and not config[0].runtime_type:
-        parser.exit(message="Please specify the type to save with -t\n", status=1)
-
-    if config[0].commands_copy:
-        if not config[0].runtime_type:
-            parser.exit(message="Please specify the type to copy to with -t\n", status=1)
-        if len(config[0].commands_copy) > 1:
-            parser.exit(message="Please specify only one type to copy to with -c\n", status=1)
-        config[0].commands_copy = config[0].commands_copy[0]
-
-    if config[0].runtime_recursive:
-        config[0].runtime_file_list = utils.get_recursive_filelist(config[0].runtime_files)
-    else:
-        config[0].runtime_file_list = config[0].runtime_files
-
-    # take a crack at finding rar exe if it's not in the path
-    if not utils.which("rar"):
-        if platform.system() == "Windows":
-            # look in some likely places for Windows machines
-            if os.path.exists(r"C:\Program Files\WinRAR\Rar.exe"):
-                utils.add_to_path(r"C:\Program Files\WinRAR")
-            elif os.path.exists(r"C:\Program Files (x86)\WinRAR\Rar.exe"):
-                utils.add_to_path(r"C:\Program Files (x86)\WinRAR")
-        else:
-            if os.path.exists("/opt/homebrew/bin"):
-                utils.add_to_path("/opt/homebrew/bin")
-
-    return config

comictaggerlib/ctsettings/file.py

@@ -1,237 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import uuid
-
-import settngs
-
-from comictaggerlib.ctsettings.types import AppendAction
-from comictaggerlib.defaults import DEFAULT_REPLACEMENTS, Replacement, Replacements
-
-
-def general(parser: settngs.Manager) -> None:
-    # General Settings
-    parser.add_setting("check_for_new_version", default=False, cmdline=False)
-
-
-def internal(parser: settngs.Manager) -> None:
-    # automatic settings
-    parser.add_setting("install_id", default=uuid.uuid4().hex, cmdline=False)
-    parser.add_setting("save_data_style", default=0, cmdline=False)
-    parser.add_setting("load_data_style", default=0, cmdline=False)
-    parser.add_setting("last_opened_folder", default="", cmdline=False)
-    parser.add_setting("window_width", default=0, cmdline=False)
-    parser.add_setting("window_height", default=0, cmdline=False)
-    parser.add_setting("window_x", default=0, cmdline=False)
-    parser.add_setting("window_y", default=0, cmdline=False)
-    parser.add_setting("form_width", default=-1, cmdline=False)
-    parser.add_setting("list_width", default=-1, cmdline=False)
-    parser.add_setting("sort_column", default=-1, cmdline=False)
-    parser.add_setting("sort_direction", default=0, cmdline=False)
-
-
-def identifier(parser: settngs.Manager) -> None:
-    # identifier settings
-    parser.add_setting("--series-match-identify-thresh", default=91, type=int, help="")
-    parser.add_setting(
-        "-b",
-        "--border-crop-percent",
-        default=10,
-        type=int,
-        help="ComicTagger will automatically add an additional cover that has any black borders cropped. If the difference in height is less than %(default)s%% the cover will not be cropped.",
-    )
-    parser.add_setting(
-        "--publisher-filter",
-        default=["Panini Comics", "Abril", "Planeta DeAgostini", "Editorial Televisa", "Dino Comics"],
-        action=AppendAction,
-        help="When enabled filters the listed publishers from all search results",
-    )
-    parser.add_setting("--series-match-search-thresh", default=90, type=int)
-    parser.add_setting(
-        "--clear-metadata",
-        default=True,
-        help="Clears all existing metadata during import, default is to merges metadata.\nMay be used in conjunction with -o, -f and -m.\n\n",
-        dest="clear_metadata_on_import",
-        action=argparse.BooleanOptionalAction,
-    )
-    parser.add_setting(
-        "-a",
-        "--auto-imprint",
-        action=argparse.BooleanOptionalAction,
-        default=False,
-        help="Enables the auto imprint functionality.\ne.g. if the publisher is set to 'vertigo' it\nwill be updated to 'DC Comics' and the imprint\nproperty will be set to 'Vertigo'.\n\n",
-    )
-
-    parser.add_setting(
-        "--sort-series-by-year", default=True, action=argparse.BooleanOptionalAction, help="Sorts series by year"
-    )
-    parser.add_setting(
-        "--exact-series-matches-first",
-        default=True,
-        action=argparse.BooleanOptionalAction,
-        help="Puts series that are an exact match at the top of the list",
-    )
-    parser.add_setting(
-        "--always-use-publisher-filter",
-        default=False,
-        action=argparse.BooleanOptionalAction,
-        help="Enables the publisher filter",
-    )
-    parser.add_setting(
-        "--clear-form-before-populating",
-        default=False,
-        action=argparse.BooleanOptionalAction,
-        help="Clears all existing metadata when applying metadata from comic source",
-    )
-
-
-def dialog(parser: settngs.Manager) -> None:
-    # Show/ask dialog flags
-    parser.add_setting("show_disclaimer", default=True, cmdline=False)
-    parser.add_setting("dont_notify_about_this_version", default="", cmdline=False)
-    parser.add_setting("ask_about_usage_stats", default=True, cmdline=False)
-
-
-def filename(parser: settngs.Manager) -> None:
-    # filename parsing settings
-    parser.add_setting(
-        "--complicated-parser",
-        default=False,
-        action=argparse.BooleanOptionalAction,
-        help="Enables the new parser which tries to extract more information from filenames",
-    )
-    parser.add_setting(
-        "--remove-c2c",
-        default=False,
-        action=argparse.BooleanOptionalAction,
-        help="Removes c2c from filenames. Requires --complicated-parser",
-    )
-    parser.add_setting(
-        "--remove-fcbd",
-        default=False,
-        action=argparse.BooleanOptionalAction,
-        help="Removes FCBD/free comic book day from filenames. Requires --complicated-parser",
-    )
-    parser.add_setting(
-        "--remove-publisher",
-        default=False,
-        action=argparse.BooleanOptionalAction,
-        help="Attempts to remove publisher names from filenames, currently limited to Marvel and DC. Requires --complicated-parser",
-    )
-
-
-def talker(parser: settngs.Manager) -> None:
-    # General settings for talkers
-    parser.add_setting("--source", default="comicvine", help="Use a specified source by source ID")
-
-
-def cbl(parser: settngs.Manager) -> None:
-    # CBL Transform settings
-    parser.add_setting("--assume-lone-credit-is-primary", default=False, action=argparse.BooleanOptionalAction)
-    parser.add_setting("--copy-characters-to-tags", default=False, action=argparse.BooleanOptionalAction)
-    parser.add_setting("--copy-teams-to-tags", default=False, action=argparse.BooleanOptionalAction)
-    parser.add_setting("--copy-locations-to-tags", default=False, action=argparse.BooleanOptionalAction)
-    parser.add_setting("--copy-storyarcs-to-tags", default=False, action=argparse.BooleanOptionalAction)
-    parser.add_setting("--copy-notes-to-comments", default=False, action=argparse.BooleanOptionalAction)
-    parser.add_setting("--copy-weblink-to-comments", default=False, action=argparse.BooleanOptionalAction)
-    parser.add_setting("--apply-transform-on-import", default=False, action=argparse.BooleanOptionalAction)
-    parser.add_setting("--apply-transform-on-bulk-operation", default=False, action=argparse.BooleanOptionalAction)
-
-
-def rename(parser: settngs.Manager) -> None:
-    # Rename settings
-    parser.add_setting("--template", default="{series} #{issue} ({year})", help="The teplate to use when renaming")
-    parser.add_setting(
-        "--issue-number-padding",
-        default=3,
-        type=int,
-        help="The minimum number of digits to use for the issue number when renaming",
-    )
-    parser.add_setting(
-        "--use-smart-string-cleanup",
-        default=True,
-        action=argparse.BooleanOptionalAction,
-        help="Attempts to intelligently cleanup whitespace when renaming",
-    )
-    parser.add_setting(
-        "--auto-extension",
-        dest="set_extension_based_on_archive",
-        default=True,
-        action=argparse.BooleanOptionalAction,
-        help="Automatically sets the extension based on the archive type e.g. cbr for rar, cbz for zip",
-    )
-    parser.add_setting("--dir", default="", help="The directory to move renamed files to")
-    parser.add_setting(
-        "--move",
-        dest="move_to_dir",
-        default=False,
-        action=argparse.BooleanOptionalAction,
-        help="Enables moving renamed files to a separate directory",
-    )
-    parser.add_setting(
-        "--strict",
-        default=False,
-        action=argparse.BooleanOptionalAction,
-        help="Ensures that filenames are valid for all OSs",
-    )
-    parser.add_setting("replacements", default=DEFAULT_REPLACEMENTS, cmdline=False)
-
-
-def autotag(parser: settngs.Manager) -> None:
-    # Auto-tag stickies
-    parser.add_setting(
-        "--save-on-low-confidence",
-        default=False,
-        action=argparse.BooleanOptionalAction,
-        help="Automatically save metadata on low-confidence matches",
-    )
-    parser.add_setting(
-        "--dont-use-year-when-identifying",
-        default=False,
-        action=argparse.BooleanOptionalAction,
-        help="Ignore the year metadata attribute when identifying a comic",
-    )
-    parser.add_setting(
-        "-1",
-        "--assume-issue-one",
-        dest="assume_1_if_no_issue_num",
-        action=argparse.BooleanOptionalAction,
-        help="Assume issue number is 1 if not found (relevant for -s).\n\n",
-        default=False,
-    )
-    parser.add_setting(
-        "--ignore-leading-numbers-in-filename",
-        default=False,
-        action=argparse.BooleanOptionalAction,
-        help="When searching ignore leading numbers in the filename",
-    )
-    parser.add_setting("remove_archive_after_successful_match", default=False, cmdline=False)
-    parser.add_setting(
-        "-w",
-        "--wait-on-rate-limit",
-        dest="wait_and_retry_on_rate_limit",
-        action=argparse.BooleanOptionalAction,
-        default=True,
-        help="When encountering a Comic Vine rate limit\nerror, wait and retry query.\n\n",
-    )
-
-
-def validate_file_settings(config: settngs.Config[settngs.Namespace]) -> settngs.Config[settngs.Namespace]:
-    config[0].identifier_publisher_filter = [x.strip() for x in config[0].identifier_publisher_filter if x.strip()]
-    config[0].rename_replacements = Replacements(
-        [Replacement(x[0], x[1], x[2]) for x in config[0].rename_replacements[0]],
-        [Replacement(x[0], x[1], x[2]) for x in config[0].rename_replacements[1]],
-    )
-    return config
-
-
-def register_file_settings(parser: settngs.Manager) -> None:
-    parser.add_group("general", general, False)
-    parser.add_group("internal", internal, False)
-    parser.add_group("identifier", identifier, False)
-    parser.add_group("dialog", dialog, False)
-    parser.add_group("filename", filename, False)
-    parser.add_group("talker", talker, False)
-    parser.add_group("cbl", cbl, False)
-    parser.add_group("rename", rename, False)
-    parser.add_group("autotag", autotag, False)

comictaggerlib/ctsettings/plugin.py

@@ -1,87 +0,0 @@
-from __future__ import annotations
-
-import logging
-import os
-
-import settngs
-
-import comicapi.comicarchive
-import comictaggerlib.ctsettings
-
-logger = logging.getLogger("comictagger")
-
-
-def archiver(manager: settngs.Manager) -> None:
-    for archiver in comicapi.comicarchive.archivers:
-        if archiver.exe:
-            # add_setting will overwrite anything with the same name.
-            # So we only end up with one option even if multiple archivers use the same exe.
-            manager.add_setting(
-                f"--{settngs.sanitize_name(archiver.exe)}",
-                default=archiver.exe,
-                help="Path to the %(default)s executable\n\n",
-            )
-
-
-def register_talker_settings(manager: settngs.Manager) -> None:
-    for talker_id, talker in comictaggerlib.ctsettings.talkers.items():
-
-        def api_options(manager: settngs.Manager) -> None:
-            manager.add_setting(
-                f"--{talker_id}-key",
-                default="",
-                display_name="API Key",
-                help=f"API Key for {talker.name} (default: {talker.default_api_key})",
-            )
-            manager.add_setting(
-                f"--{talker_id}-url",
-                default="",
-                display_name="URL",
-                help=f"URL for {talker.name} (default: {talker.default_api_url})",
-            )
-
-        try:
-            manager.add_persistent_group("talker_" + talker_id, api_options, False)
-            manager.add_persistent_group("talker_" + talker_id, talker.register_settings, False)
-        except Exception:
-            logger.exception("Failed to register settings for %s", talker_id)
-
-
-def validate_archive_settings(config: settngs.Config[settngs.Namespace]) -> settngs.Config[settngs.Namespace]:
-    if "archiver" not in config[1]:
-        return config
-    cfg = settngs.normalize_config(config, file=True, cmdline=True, defaults=False)
-    for archiver in comicapi.comicarchive.archivers:
-        exe_name = settngs.sanitize_name(archiver.exe)
-        if exe_name in cfg[0]["archiver"] and cfg[0]["archiver"][exe_name]:
-            if os.path.basename(cfg[0]["archiver"][exe_name]) == archiver.exe:
-                comicapi.utils.add_to_path(os.path.dirname(cfg[0]["archiver"][exe_name]))
-            else:
-                archiver.exe = cfg[0]["archiver"][exe_name]
-
-    return config
-
-
-def validate_talker_settings(config: settngs.Config[settngs.Namespace]) -> settngs.Config[settngs.Namespace]:
-    # Apply talker settings from config file
-    cfg = settngs.normalize_config(config, True, True)
-    for talker_id, talker in list(comictaggerlib.ctsettings.talkers.items()):
-        try:
-            cfg[0]["talker_" + talker_id] = talker.parse_settings(cfg[0]["talker_" + talker_id])
-        except Exception as e:
-            # Remove talker as we failed to apply the settings
-            del comictaggerlib.ctsettings.talkers[talker_id]
-            logger.exception("Failed to initialize talker settings: %s", e)
-
-    return settngs.get_namespace(cfg)
-
-
-def validate_plugin_settings(config: settngs.Config[settngs.Namespace]) -> settngs.Config[settngs.Namespace]:
-    config = validate_archive_settings(config)
-    config = validate_talker_settings(config)
-    return config
-
-
-def register_plugin_settings(manager: settngs.Manager) -> None:
-    manager.add_persistent_group("archiver", archiver, False)
-    register_talker_settings(manager)

comictaggerlib/ctsettings/types.py

@@ -1,186 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import pathlib
-from collections.abc import Sequence
-from typing import Any, Callable
-
-from appdirs import AppDirs
-
-from comicapi.comicarchive import MetaDataStyle
-from comicapi.genericmetadata import GenericMetadata
-
-
-class ComicTaggerPaths(AppDirs):
-    def __init__(self, config_path: pathlib.Path | str | None = None) -> None:
-        super().__init__("ComicTagger", None, None, False, False)
-        self.path: pathlib.Path | None = None
-        if config_path:
-            self.path = pathlib.Path(config_path).absolute()
-
-    @property
-    def user_data_dir(self) -> pathlib.Path:
-        if self.path:
-            return self.path
-        return pathlib.Path(super().user_data_dir)
-
-    @property
-    def user_config_dir(self) -> pathlib.Path:
-        if self.path:
-            return self.path
-        return pathlib.Path(super().user_config_dir)
-
-    @property
-    def user_cache_dir(self) -> pathlib.Path:
-        if self.path:
-            path = self.path / "cache"
-            return path
-        return pathlib.Path(super().user_cache_dir)
-
-    @property
-    def user_state_dir(self) -> pathlib.Path:
-        if self.path:
-            return self.path
-        return pathlib.Path(super().user_state_dir)
-
-    @property
-    def user_log_dir(self) -> pathlib.Path:
-        if self.path:
-            path = self.path / "log"
-            return path
-        return pathlib.Path(super().user_log_dir)
-
-    @property
-    def site_data_dir(self) -> pathlib.Path:
-        return pathlib.Path(super().site_data_dir)
-
-    @property
-    def site_config_dir(self) -> pathlib.Path:
-        return pathlib.Path(super().site_config_dir)
-
-
-def metadata_type(types: str) -> list[int]:
-    result = []
-    types = types.casefold()
-    for typ in types.split(","):
-        typ = typ.strip()
-        if typ not in MetaDataStyle.short_name:
-            choices = ", ".join(MetaDataStyle.short_name)
-            raise argparse.ArgumentTypeError(f"invalid choice: {typ} (choose from {choices.upper()})")
-        result.append(MetaDataStyle.short_name.index(typ))
-    return result
-
-
-def _copy_items(items: Sequence[Any] | None) -> Sequence[Any]:
-    if items is None:
-        return []
-    # The copy module is used only in the 'append' and 'append_const'
-    # actions, and it is needed only when the default value isn't a list.
-    # Delay its import for speeding up the common case.
-    if type(items) is list:
-        return items[:]
-    import copy
-
-    return copy.copy(items)
-
-
-class AppendAction(argparse.Action):
-    def __init__(
-        self,
-        option_strings: list[str],
-        dest: str,
-        nargs: str | None = None,
-        const: Any = None,
-        default: Any = None,
-        type: Callable[[str], Any] | None = None,  # noqa: A002
-        choices: list[Any] | None = None,
-        required: bool = False,
-        help: str | None = None,  # noqa: A002
-        metavar: str | None = None,
-    ):
-        self.called = False
-        if nargs == 0:
-            raise ValueError(
-                "nargs for append actions must be != 0; if arg "
-                "strings are not supplying the value to append, "
-                "the append const action may be more appropriate"
-            )
-        if const is not None and nargs != argparse.OPTIONAL:
-            raise ValueError("nargs must be %r to supply const" % argparse.OPTIONAL)
-        super().__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=nargs,
-            const=const,
-            default=default,
-            type=type,
-            choices=choices,
-            required=required,
-            help=help,
-            metavar=metavar,
-        )
-
-    def __call__(
-        self,
-        parser: argparse.ArgumentParser,
-        namespace: argparse.Namespace,
-        values: str | Sequence[Any] | None,
-        option_string: str | None = None,
-    ) -> None:
-        if values:
-            if not self.called:
-                setattr(namespace, self.dest, [])
-            items = getattr(namespace, self.dest, None)
-            items = _copy_items(items)
-            items.append(values)  # type: ignore
-            setattr(namespace, self.dest, items)
-
-
-def parse_metadata_from_string(mdstr: str) -> GenericMetadata:
-    """The metadata string is a comma separated list of name-value pairs
-    The names match the attributes of the internal metadata struct (for now)
-    The caret is the special "escape character", since it's not common in
-    natural language text
-
-    example = "series=Kickers^, Inc. ,issue=1, year=1986"
-    """
-
-    escaped_comma = "^,"
-    escaped_equals = "^="
-    replacement_token = "<_~_>"
-
-    md = GenericMetadata()
-
-    # First, replace escaped commas with with a unique token (to be changed back later)
-    mdstr = mdstr.replace(escaped_comma, replacement_token)
-    tmp_list = mdstr.split(",")
-    md_list = []
-    for item in tmp_list:
-        item = item.replace(replacement_token, ",")
-        md_list.append(item)
-
-    # Now build a nice dict from the list
-    md_dict = {}
-    for item in md_list:
-        # Make sure to fix any escaped equal signs
-        i = item.replace(escaped_equals, replacement_token)
-        key, value = i.split("=")
-        value = value.replace(replacement_token, "=").strip()
-        key = key.strip()
-        if key.casefold() == "credit":
-            cred_attribs = value.split(":")
-            role = cred_attribs[0]
-            person = cred_attribs[1] if len(cred_attribs) > 1 else ""
-            primary = len(cred_attribs) > 2
-            md.add_credit(person.strip(), role.strip(), primary)
-        else:
-            md_dict[key] = value
-
-    # Map the dict to the metadata object
-    for key, value in md_dict.items():
-        if not hasattr(md, key):
-            raise argparse.ArgumentTypeError(f"'{key}' is not a valid tag name")
-        else:
-            md.is_empty = False
-            setattr(md, key, value)
-    return md

comictaggerlib/defaults.py

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-from typing import NamedTuple
-
-
-class Replacement(NamedTuple):
-    find: str
-    replce: str
-    strict_only: bool
-
-
-class Replacements(NamedTuple):
-    literal_text: list[Replacement]
-    format_value: list[Replacement]
-
-
-DEFAULT_REPLACEMENTS = Replacements(
-    literal_text=[
-        Replacement(": ", " - ", True),
-        Replacement(":", "-", True),
-    ],
-    format_value=[
-        Replacement(": ", " - ", True),
-        Replacement(":", "-", True),
-        Replacement("/", "-", False),
-        Replacement("//", "--", False),
-        Replacement("\\", "-", True),
-    ],
-)

comictaggerlib/exportwindow.py

@@ -1,27 +1,22 @@
 """A PyQT4 dialog to confirm and set options for export to zip"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import logging
+from PyQt5 import QtCore, QtGui, QtWidgets, uic
 
-from PyQt5 import QtCore, QtWidgets, uic
-
-from comictaggerlib.ui import ui_path
-
-logger = logging.getLogger(__name__)
+from .settings import ComicTaggerSettings
 
 
 class ExportConflictOpts:
@@ -31,25 +26,25 @@ class ExportConflictOpts:
 
 
 class ExportWindow(QtWidgets.QDialog):
-    def __init__(self, parent: QtWidgets.QWidget, msg: str) -> None:
-        super().__init__(parent)
+    def __init__(self, parent, settings, msg):
+        super(ExportWindow, self).__init__(parent)
 
-        uic.loadUi(ui_path / "exportwindow.ui", self)
+        uic.loadUi(ComicTaggerSettings.getUIFile("exportwindow.ui"), self)
         self.label.setText(msg)
 
-        self.setWindowFlags(
-            QtCore.Qt.WindowType(self.windowFlags() & ~QtCore.Qt.WindowType.WindowContextHelpButtonHint)
-        )
+        self.setWindowFlags(self.windowFlags() & ~QtCore.Qt.WindowContextHelpButtonHint)
 
-        self.cbxDeleteOriginal.setChecked(False)
-        self.cbxAddToList.setChecked(True)
+        self.settings = settings
+
+        self.cbxDeleteOriginal.setCheckState(QtCore.Qt.Unchecked)
+        self.cbxAddToList.setCheckState(QtCore.Qt.Checked)
         self.radioDontCreate.setChecked(True)
 
         self.deleteOriginal = False
         self.addToList = True
         self.fileConflictBehavior = ExportConflictOpts.dontCreate
 
-    def accept(self) -> None:
+    def accept(self):
         QtWidgets.QDialog.accept(self)
 
         self.deleteOriginal = self.cbxDeleteOriginal.isChecked()
@@ -58,3 +53,5 @@ class ExportWindow(QtWidgets.QDialog):
             self.fileConflictBehavior = ExportConflictOpts.dontCreate
         elif self.radioCreateNew.isChecked():
             self.fileConflictBehavior = ExportConflictOpts.createUnique
+        # else:
+        #    self.fileConflictBehavior = ExportConflictOpts.overwrite

comictaggerlib/filenameparser.py

@@ -0,0 +1 @@
+from comicapi.filenameparser import *

comictaggerlib/filerenamer.py

@@ -1,245 +1,144 @@
 """Functions for renaming files based on metadata"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import calendar
-import logging
 import os
-import pathlib
+import re
 import string
-from collections.abc import Mapping, Sequence
-from typing import Any, cast
+import sys
 
-from pathvalidate import Platform, normalize_platform, sanitize_filename
+from pathvalidate import sanitize_filepath
 
-from comicapi.comicarchive import ComicArchive
-from comicapi.genericmetadata import GenericMetadata
-from comicapi.issuestring import IssueString
-from comictaggerlib.defaults import DEFAULT_REPLACEMENTS, Replacement, Replacements
-
-logger = logging.getLogger(__name__)
-
-
-def get_rename_dir(ca: ComicArchive, rename_dir: str | pathlib.Path | None) -> pathlib.Path:
-    folder = ca.path.parent.absolute()
-    if rename_dir is not None:
-        if isinstance(rename_dir, str):
-            rename_dir = rename_dir.strip()
-        folder = pathlib.Path(rename_dir).absolute()
-    return folder
+from . import utils
+from .issuestring import IssueString
 
 
 class MetadataFormatter(string.Formatter):
-    def __init__(
-        self, smart_cleanup: bool = False, platform: str = "auto", replacements: Replacements = DEFAULT_REPLACEMENTS
-    ) -> None:
+    def __init__(self, smart_cleanup=False):
         super().__init__()
         self.smart_cleanup = smart_cleanup
-        self.platform = normalize_platform(platform)
-        self.replacements = replacements
 
-    def format_field(self, value: Any, format_spec: str) -> str:
+    def format_field(self, value, format_spec):
         if value is None or value == "":
             return ""
-        return cast(str, super().format_field(value, format_spec))
+        return super().format_field(value, format_spec)
 
-    def convert_field(self, value: Any, conversion: str) -> str:
-        if conversion == "u":
-            return str(value).upper()
-        if conversion == "l":
-            return str(value).casefold()
-        if conversion == "c":
-            return str(value).capitalize()
-        if conversion == "S":
-            return str(value).swapcase()
-        if conversion == "t":
-            return str(value).title()
-        return cast(str, super().convert_field(value, conversion))
-
-    def handle_replacements(self, string: str, replacements: list[Replacement]) -> str:
-        for find, replace, strict_only in replacements:
-            if self.is_strict() or not strict_only:
-                string = string.replace(find, replace)
-        return string
-
-    def none_replacement(self, value: Any, replacement: str, r: str) -> Any:
-        if r == "-" and value is None or value == "":
-            return replacement
-        if r == "+" and value is not None:
-            return replacement
-        return value
-
-    def split_replacement(self, field_name: str) -> tuple[str, str, str]:
-        if "-" in field_name:
-            return field_name.rpartition("-")
-        if "+" in field_name:
-            return field_name.rpartition("+")
-        return field_name, "", ""
-
-    def is_strict(self) -> bool:
-        return self.platform in [Platform.UNIVERSAL, Platform.WINDOWS]
-
-    def _vformat(
-        self,
-        format_string: str,
-        args: Sequence[Any],
-        kwargs: Mapping[str, Any],
-        used_args: set[Any],
-        recursion_depth: int,
-        auto_arg_index: int = 0,
-    ) -> tuple[str, int]:
+    def _vformat(self, format_string, args, kwargs, used_args, recursion_depth, auto_arg_index=0):
         if recursion_depth < 0:
             raise ValueError("Max string recursion exceeded")
         result = []
         lstrip = False
         for literal_text, field_name, format_spec, conversion in self.parse(format_string):
+
             # output the literal text
             if literal_text:
                 if lstrip:
-                    literal_text = literal_text.lstrip("-_)}]#")
-                if self.smart_cleanup:
-                    literal_text = self.handle_replacements(literal_text, self.replacements.literal_text)
-                    lspace = literal_text[0].isspace() if literal_text else False
-                    rspace = literal_text[-1].isspace() if literal_text else False
-                    literal_text = " ".join(literal_text.split())
-                    if literal_text == "":
-                        literal_text = " "
-                    else:
-                        if lspace:
-                            literal_text = " " + literal_text
-                        if rspace:
-                            literal_text += " "
-                result.append(literal_text)
-
+                    result.append(literal_text.lstrip("-_)}]#"))
+                else:
+                    result.append(literal_text)
             lstrip = False
             # if there's a field, output it
-            if field_name is not None and field_name != "":
-                field_name, r, replacement = self.split_replacement(field_name)
-                field_name = field_name.casefold()
-                # this is some markup, find the object and do the formatting
+            if field_name is not None:
+                # this is some markup, find the object and do
+                #  the formatting
 
-                # handle arg indexing when digit field_names are given.
-                if field_name.isdigit():
-                    raise ValueError("cannot use a number as a field name")
+                # handle arg indexing when empty field_names are given.
+                if field_name == "":
+                    if auto_arg_index is False:
+                        raise ValueError("cannot switch from manual field specification to automatic field numbering")
+                    field_name = str(auto_arg_index)
+                    auto_arg_index += 1
+                elif field_name.isdigit():
+                    if auto_arg_index:
+                        raise ValueError("cannot switch from manual field specification to automatic field numbering")
+                    # disable auto arg incrementing, if it gets
+                    # used later on, then an exception will be raised
+                    auto_arg_index = False
 
                 # given the field_name, find the object it references
                 #  and the argument it came from
                 obj, arg_used = self.get_field(field_name, args, kwargs)
                 used_args.add(arg_used)
 
-                obj = self.none_replacement(obj, replacement, r)
-
                 # do any conversion on the resulting object
-                obj = self.convert_field(obj, conversion)  # type: ignore
+                obj = self.convert_field(obj, conversion)
 
                 # expand the format spec, if needed
-                format_spec, _ = self._vformat(
-                    cast(str, format_spec), args, kwargs, used_args, recursion_depth - 1, auto_arg_index=False
-                )
+                format_spec, auto_arg_index = self._vformat(format_spec, args, kwargs, used_args, recursion_depth - 1, auto_arg_index=auto_arg_index)
 
                 # format the object and append to the result
-                fmt_obj = self.format_field(obj, format_spec)
-                if fmt_obj == "" and result and self.smart_cleanup and literal_text:
-                    if self.str_contains(result[-1], "({["):
-                        lstrip = True
-                    if result:
-                        if " " in result[-1]:
-                            result[-1], _, _ = result[-1].rstrip().rpartition(" ")
-                        result[-1] = result[-1].rstrip("-_({[#")
-                if self.smart_cleanup:
-                    # colons and slashes get special treatment
-                    fmt_obj = self.handle_replacements(fmt_obj, self.replacements.format_value)
-                    fmt_obj = " ".join(fmt_obj.split())
-                    fmt_obj = str(sanitize_filename(fmt_obj, platform=self.platform))
-                result.append(fmt_obj)
+                fmtObj = self.format_field(obj, format_spec)
+                if fmtObj == "" and len(result) > 0 and self.smart_cleanup:
+                    lstrip = True
+                    result.pop()
+                result.append(fmtObj)
 
-        return "".join(result), False
-
-    def str_contains(self, chars: str, string: str) -> bool:
-        for char in chars:
-            if char in string:
-                return True
-        return False
+        return "".join(result), auto_arg_index
 
 
 class FileRenamer:
-    def __init__(
-        self,
-        metadata: GenericMetadata | None,
-        platform: str = "auto",
-        replacements: Replacements = DEFAULT_REPLACEMENTS,
-    ) -> None:
-        self.template = "{publisher}/{series}/{series} v{volume} #{issue} (of {issue_count}) ({year})"
+    def __init__(self, metadata):
+        self.setMetadata(metadata)
+        self.setTemplate("{publisher}/{series}/{series} v{volume} #{issue} (of {issueCount}) ({year})")
         self.smart_cleanup = True
         self.issue_zero_padding = 3
-        self.metadata = metadata or GenericMetadata()
         self.move = False
-        self.platform = platform
-        self.replacements = replacements
 
-    def set_metadata(self, metadata: GenericMetadata) -> None:
-        self.metadata = metadata
+    def setMetadata(self, metadata):
+        self.metdata = metadata
 
-    def set_issue_zero_padding(self, count: int) -> None:
+    def setIssueZeroPadding(self, count):
         self.issue_zero_padding = count
 
-    def set_smart_cleanup(self, on: bool) -> None:
+    def setSmartCleanup(self, on):
         self.smart_cleanup = on
 
-    def set_template(self, template: str) -> None:
+    def setTemplate(self, template):
         self.template = template
 
-    def determine_name(self, ext: str) -> str:
-        class Default(dict[str, Any]):
-            def __missing__(self, key: str) -> str:
+    def determineName(self, filename, ext=None):
+        class Default(dict):
+            def __missing__(self, key):
                 return "{" + key + "}"
 
-        md = self.metadata
+        md = self.metdata
 
         # padding for issue
-        md.issue = IssueString(md.issue).as_string(pad=self.issue_zero_padding)
+        md.issue = IssueString(md.issue).asString(pad=self.issue_zero_padding)
 
         template = self.template
 
+        pathComponents = template.split(os.sep)
         new_name = ""
 
-        fmt = MetadataFormatter(self.smart_cleanup, platform=self.platform, replacements=self.replacements)
-        md_dict = vars(md)
-        for role in ["writer", "penciller", "inker", "colorist", "letterer", "cover artist", "editor"]:
-            md_dict[role] = md.get_primary_credit(role)
+        fmt = MetadataFormatter(self.smart_cleanup)
+        for Component in pathComponents:
+            new_name = os.path.join(new_name, fmt.vformat(Component, args=[], kwargs=Default(vars(md))).replace("/", "-"))
 
-        if (isinstance(md.month, int) or isinstance(md.month, str) and md.month.isdigit()) and 0 < int(md.month) < 13:
-            md_dict["month_name"] = calendar.month_name[int(md.month)]
-            md_dict["month_abbr"] = calendar.month_abbr[int(md.month)]
-        else:
-            md_dict["month_name"] = ""
-            md_dict["month_abbr"] = ""
-
-        new_basename = ""
-        for component in pathlib.PureWindowsPath(template).parts:
-            new_basename = str(
-                sanitize_filename(fmt.vformat(component, args=[], kwargs=Default(md_dict)), platform=self.platform)
-            ).strip()
-            new_name = os.path.join(new_name, new_basename)
+        if ext is None or ext == "":
+            ext = os.path.splitext(filename)[1]
 
         new_name += ext
-        new_basename += ext
+
+        # some tweaks to keep various filesystems happy
+        new_name = new_name.replace(": ", " - ")
+        new_name = new_name.replace(":", "-")
 
         # remove padding
-        md.issue = IssueString(md.issue).as_string()
+        md.issue = IssueString(md.issue).asString()
         if self.move:
-            return new_name.strip()
-        return new_basename.strip()
+            return sanitize_filepath(new_name.strip())
+        else:
+            return os.path.basename(sanitize_filepath(new_name.strip()))

comictaggerlib/fileselectionlist.py

@@ -1,52 +1,54 @@
+# coding=utf-8
 """A PyQt5 widget for managing list of comic archive files"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import logging
 import os
 import platform
-from typing import Callable, cast
+import sys
 
-import settngs
-from PyQt5 import QtCore, QtWidgets, uic
+from PyQt5 import uic
+from PyQt5.QtCore import *
+from PyQt5.QtCore import pyqtSignal
+from PyQt5.QtGui import *
+from PyQt5.QtWidgets import *
 
-from comicapi import utils
-from comicapi.comicarchive import ComicArchive
-from comictaggerlib.graphics import graphics_path
-from comictaggerlib.optionalmsgdialog import OptionalMessageDialog
-from comictaggerlib.settingswindow import linuxRarHelp, macRarHelp, windowsRarHelp
-from comictaggerlib.ui import ui_path
-from comictaggerlib.ui.qtutils import center_window_on_parent, reduce_widget_font_size
+from comictaggerlib.ui.qtutils import centerWindowOnParent, reduceWidgetFontSize
 
-logger = logging.getLogger(__name__)
+from . import utils
+from .comicarchive import ComicArchive
+from .optionalmsgdialog import OptionalMessageDialog
+from .settings import ComicTaggerSettings
 
 
-class FileTableWidgetItem(QtWidgets.QTableWidgetItem):
-    def __lt__(self, other: object) -> bool:
-        return self.data(QtCore.Qt.ItemDataRole.UserRole) < other.data(QtCore.Qt.ItemDataRole.UserRole)  # type: ignore
+class FileTableWidgetItem(QTableWidgetItem):
+    def __lt__(self, other):
+        # return (self.data(Qt.UserRole).toBool() <
+        #        other.data(Qt.UserRole).toBool())
+        return self.data(Qt.UserRole) < other.data(Qt.UserRole)
 
 
 class FileInfo:
-    def __init__(self, ca: ComicArchive) -> None:
-        self.ca: ComicArchive = ca
+    def __init__(self, ca):
+        self.ca = ca
 
 
-class FileSelectionList(QtWidgets.QWidget):
-    selectionChanged = QtCore.pyqtSignal(QtCore.QVariant)
-    listCleared = QtCore.pyqtSignal()
+class FileSelectionList(QWidget):
+
+    selectionChanged = pyqtSignal(QVariant)
+    listCleared = pyqtSignal()
 
     fileColNum = 0
     CRFlagColNum = 1
@@ -56,94 +58,77 @@ class FileSelectionList(QtWidgets.QWidget):
     folderColNum = 5
     dataColNum = fileColNum
 
-    def __init__(
-        self, parent: QtWidgets.QWidget, config: settngs.Namespace, dirty_flag_verification: Callable[[str, str], bool]
-    ) -> None:
-        super().__init__(parent)
+    def __init__(self, parent, settings):
+        super(FileSelectionList, self).__init__(parent)
 
-        uic.loadUi(ui_path / "fileselectionlist.ui", self)
+        uic.loadUi(ComicTaggerSettings.getUIFile("fileselectionlist.ui"), self)
 
-        self.config = config
+        self.settings = settings
 
-        reduce_widget_font_size(self.twList)
+        reduceWidgetFontSize(self.twList)
 
         self.twList.setColumnCount(6)
-        self.twList.currentItemChanged.connect(self.current_item_changed_cb)
+        # self.twlist.setHorizontalHeaderLabels (["File", "Folder", "CR", "CBL", ""])
+        # self.twList.horizontalHeader().setStretchLastSection(True)
+        self.twList.currentItemChanged.connect(self.currentItemChangedCB)
 
         self.currentItem = None
-        self.setContextMenuPolicy(QtCore.Qt.ContextMenuPolicy.ActionsContextMenu)
-        self.dirty_flag = False
+        self.setContextMenuPolicy(Qt.ActionsContextMenu)
+        self.modifiedFlag = False
 
-        select_all_action = QtWidgets.QAction("Select All", self)
-        remove_action = QtWidgets.QAction("Remove Selected Items", self)
-        self.separator = QtWidgets.QAction("", self)
+        selectAllAction = QAction("Select All", self)
+        removeAction = QAction("Remove Selected Items", self)
+        self.separator = QAction("", self)
         self.separator.setSeparator(True)
 
-        select_all_action.setShortcut("Ctrl+A")
-        remove_action.setShortcut("Ctrl+X")
+        selectAllAction.setShortcut("Ctrl+A")
+        removeAction.setShortcut("Ctrl+X")
 
-        select_all_action.triggered.connect(self.select_all)
-        remove_action.triggered.connect(self.remove_selection)
+        selectAllAction.triggered.connect(self.selectAll)
+        removeAction.triggered.connect(self.removeSelection)
 
-        self.addAction(select_all_action)
-        self.addAction(remove_action)
+        self.addAction(selectAllAction)
+        self.addAction(removeAction)
         self.addAction(self.separator)
 
-        self.dirty_flag_verification = dirty_flag_verification
-        self.rar_ro_shown = False
-
-    def get_sorting(self) -> tuple[int, int]:
+    def getSorting(self):
         col = self.twList.horizontalHeader().sortIndicatorSection()
         order = self.twList.horizontalHeader().sortIndicatorOrder()
-        return int(col), int(order)
+        return col, order
 
-    def set_sorting(self, col: int, order: QtCore.Qt.SortOrder) -> None:
-        self.twList.horizontalHeader().setSortIndicator(col, order)
+    def setSorting(self, col, order):
+        col = self.twList.horizontalHeader().setSortIndicator(col, order)
 
-    def add_app_action(self, action: QtWidgets.QAction) -> None:
-        self.insertAction(QtWidgets.QAction(), action)
+    def addAppAction(self, action):
+        self.insertAction(None, action)
 
-    def set_modified_flag(self, modified: bool) -> None:
-        self.dirty_flag = modified
+    def setModifiedFlag(self, modified):
+        self.modifiedFlag = modified
 
-    def select_all(self) -> None:
-        self.twList.setRangeSelected(QtWidgets.QTableWidgetSelectionRange(0, 0, self.twList.rowCount() - 1, 5), True)
+    def selectAll(self):
+        self.twList.setRangeSelected(QTableWidgetSelectionRange(0, 0, self.twList.rowCount() - 1, 5), True)
 
-    def deselect_all(self) -> None:
-        self.twList.setRangeSelected(QtWidgets.QTableWidgetSelectionRange(0, 0, self.twList.rowCount() - 1, 5), False)
+    def deselectAll(self):
+        self.twList.setRangeSelected(QTableWidgetSelectionRange(0, 0, self.twList.rowCount() - 1, 5), False)
 
-    def remove_archive_list(self, ca_list: list[ComicArchive]) -> None:
+    def removeArchiveList(self, ca_list):
         self.twList.setSortingEnabled(False)
-        current_removed = False
         for ca in ca_list:
             for row in range(self.twList.rowCount()):
-                row_ca = self.get_archive_by_row(row)
+                row_ca = self.getArchiveByRow(row)
                 if row_ca == ca:
-                    if row == self.twList.currentRow():
-                        current_removed = True
                     self.twList.removeRow(row)
                     break
         self.twList.setSortingEnabled(True)
 
-        if self.twList.rowCount() > 0 and current_removed:
-            # since on a removal, we select row 0, make sure callback occurs if
-            # we're already there
-            if self.twList.currentRow() == 0:
-                self.current_item_changed_cb(self.twList.currentItem(), None)
-            self.twList.selectRow(0)
-        elif self.twList.rowCount() <= 0:
-            self.listCleared.emit()
+    def getArchiveByRow(self, row):
+        fi = self.twList.item(row, FileSelectionList.dataColNum).data(Qt.UserRole)
+        return fi.ca
 
-    def get_archive_by_row(self, row: int) -> ComicArchive | None:
-        if row >= 0:
-            fi: FileInfo = self.twList.item(row, FileSelectionList.dataColNum).data(QtCore.Qt.ItemDataRole.UserRole)
-            return fi.ca
-        return None
+    def getCurrentArchive(self):
+        return self.getArchiveByRow(self.twList.currentRow())
 
-    def get_current_archive(self) -> ComicArchive | None:
-        return self.get_archive_by_row(self.twList.currentRow())
-
-    def remove_selection(self) -> None:
+    def removeSelection(self):
         row_list = []
         for item in self.twList.selectedItems():
             if item.column() == 0:
@@ -153,77 +138,95 @@ class FileSelectionList(QtWidgets.QWidget):
             return
 
         if self.twList.currentRow() in row_list:
-            if not self.dirty_flag_verification(
-                "Remove Archive", "If you close this archive, data in the form will be lost.  Are you sure?"
-            ):
+            if not self.modifiedFlagVerification("Remove Archive", "If you close this archive, data in the form will be lost.  Are you sure?"):
                 return
 
         row_list.sort()
         row_list.reverse()
 
-        self.twList.currentItemChanged.disconnect(self.current_item_changed_cb)
+        self.twList.currentItemChanged.disconnect(self.currentItemChangedCB)
         self.twList.setSortingEnabled(False)
 
         for i in row_list:
             self.twList.removeRow(i)
 
         self.twList.setSortingEnabled(True)
-        self.twList.currentItemChanged.connect(self.current_item_changed_cb)
+        self.twList.currentItemChanged.connect(self.currentItemChangedCB)
 
         if self.twList.rowCount() > 0:
             # since on a removal, we select row 0, make sure callback occurs if
             # we're already there
             if self.twList.currentRow() == 0:
-                self.current_item_changed_cb(self.twList.currentItem(), None)
+                self.currentItemChangedCB(self.twList.currentItem(), None)
             self.twList.selectRow(0)
         else:
             self.listCleared.emit()
 
-    def add_path_list(self, pathlist: list[str]) -> None:
+    def addPathList(self, pathlist):
+
         filelist = utils.get_recursive_filelist(pathlist)
         # we now have a list of files to add
 
         # Prog dialog on Linux flakes out for small range, so scale up
-        progdialog = QtWidgets.QProgressDialog("", "Cancel", 0, len(filelist), parent=self)
+        progdialog = QProgressDialog("", "Cancel", 0, len(filelist), parent=self)
         progdialog.setWindowTitle("Adding Files")
-        progdialog.setWindowModality(QtCore.Qt.WindowModality.ApplicationModal)
+        progdialog.setWindowModality(Qt.ApplicationModal)
         progdialog.setMinimumDuration(300)
-        center_window_on_parent(progdialog)
+        centerWindowOnParent(progdialog)
+        # QCoreApplication.processEvents()
+        # progdialog.show()
 
-        QtCore.QCoreApplication.processEvents()
-        first_added = None
-        rar_added_ro = False
+        QCoreApplication.processEvents()
+        firstAdded = None
         self.twList.setSortingEnabled(False)
         for idx, f in enumerate(filelist):
-            QtCore.QCoreApplication.processEvents()
+            QCoreApplication.processEvents()
             if progdialog.wasCanceled():
                 break
             progdialog.setValue(idx + 1)
             progdialog.setLabelText(f)
-            center_window_on_parent(progdialog)
-            QtCore.QCoreApplication.processEvents()
-            row = self.add_path_item(f)
-            if row is not None:
-                ca = self.get_archive_by_row(row)
-                rar_added_ro = bool(ca and ca.archiver.name() == "RAR" and not ca.archiver.is_writable())
-                if first_added is None:
-                    first_added = row
+            centerWindowOnParent(progdialog)
+            QCoreApplication.processEvents()
+            row = self.addPathItem(f)
+            if firstAdded is None and row is not None:
+                firstAdded = row
 
         progdialog.hide()
-        QtCore.QCoreApplication.processEvents()
+        QCoreApplication.processEvents()
 
-        if first_added is not None:
-            self.twList.selectRow(first_added)
+        if self.settings.show_no_unrar_warning and self.settings.unrar_lib_path == "" and not ComicTaggerSettings.haveOwnUnrarLib():
+            for f in filelist:
+                ext = os.path.splitext(f)[1].lower()
+                if ext == ".rar" or ext == ".cbr":
+                    checked = OptionalMessageDialog.msg(
+                        self,
+                        "No UnRAR Ability",
+                        """
+                            It looks like you've tried to open at least one CBR or RAR file.<br><br>
+                            In order for ComicTagger to read this kind of file, you will have to configure
+                            the location of the unrar library in the settings.  Until then, ComicTagger
+                            will not be able read these kind of files. See the "RAR Tools" tab in the
+                            settings/preferences for more info.
+                            """,
+                    )
+                    self.settings.show_no_unrar_warning = not checked
+                    break
+
+        if firstAdded is not None:
+            self.twList.selectRow(firstAdded)
         else:
             if len(pathlist) == 1 and os.path.isfile(pathlist[0]):
-                QtWidgets.QMessageBox.information(
-                    self, "File Open", "Selected file doesn't seem to be a comic archive."
-                )
+                ext = os.path.splitext(pathlist[0])[1].lower()
+                if ext == ".rar" or ext == ".cbr" and self.settings.unrar_lib_path == "":
+                    QMessageBox.information(
+                        self,
+                        self.tr("File Open"),
+                        self.tr("Selected file seems to be a rar file, " "and can't be read until the unrar library is configured."),
+                    )
+                else:
+                    QMessageBox.information(self, self.tr("File Open"), self.tr("Selected file doesn't seem to be a comic archive."))
             else:
-                QtWidgets.QMessageBox.information(self, "File/Folder Open", "No readable comic archives were found.")
-
-        if rar_added_ro:
-            self.rar_ro_message()
+                QMessageBox.information(self, self.tr("File/Folder Open"), self.tr("No readable comic archives were found."))
 
         self.twList.setSortingEnabled(True)
 
@@ -238,182 +241,194 @@ class FileSelectionList(QtWidgets.QWidget):
         if self.twList.columnWidth(FileSelectionList.folderColNum) > 200:
             self.twList.setColumnWidth(FileSelectionList.folderColNum, 200)
 
-    def rar_ro_message(self) -> None:
-        if not self.rar_ro_shown:
-            if platform.system() == "Windows":
-                rar_help = windowsRarHelp
+    def isListDupe(self, path):
+        r = 0
+        while r < self.twList.rowCount():
+            ca = self.getArchiveByRow(r)
+            if ca.path == path:
+                return True
+            r = r + 1
 
-            elif platform.system() == "Darwin":
-                rar_help = macRarHelp
+        return False
 
-            else:
-                rar_help = linuxRarHelp
-
-            OptionalMessageDialog.msg_no_checkbox(
-                self,
-                "RAR Files are Read-Only",
-                "It looks like you have opened a RAR/CBR archive,\n"
-                "however ComicTagger cannot currently write to them without the rar program and are marked read only!\n\n"
-                f"{rar_help}",
-            )
-            self.rar_ro_shown = True
-
-    def is_list_dupe(self, path: str) -> bool:
-        return self.get_current_list_row(path) >= 0
-
-    def get_current_list_row(self, path: str) -> int:
-        for r in range(self.twList.rowCount()):
-            ca = cast(ComicArchive, self.get_archive_by_row(r))
-            if str(ca.path) == path:
+    def getCurrentListRow(self, path):
+        r = 0
+        while r < self.twList.rowCount():
+            ca = self.getArchiveByRow(r)
+            if ca.path == path:
                 return r
+            r = r + 1
 
         return -1
 
-    def add_path_item(self, path: str) -> int:
+    def addPathItem(self, path):
         path = str(path)
         path = os.path.abspath(path)
+        # print "processing", path
 
-        if self.is_list_dupe(path):
-            return self.get_current_list_row(path)
+        if self.isListDupe(path):
+            return self.getCurrentListRow(path)
 
-        ca = ComicArchive(path, str(graphics_path / "nocover.png"))
+        ca = ComicArchive(path, self.settings.rar_exe_path, ComicTaggerSettings.getGraphic("nocover.png"))
 
-        if ca.seems_to_be_a_comic_archive():
-            row: int = self.twList.rowCount()
+        if ca.seemsToBeAComicArchive():
+            row = self.twList.rowCount()
             self.twList.insertRow(row)
 
             fi = FileInfo(ca)
 
-            filename_item = QtWidgets.QTableWidgetItem()
-            folder_item = QtWidgets.QTableWidgetItem()
+            filename_item = QTableWidgetItem()
+            folder_item = QTableWidgetItem()
             cix_item = FileTableWidgetItem()
             cbi_item = FileTableWidgetItem()
             readonly_item = FileTableWidgetItem()
-            type_item = QtWidgets.QTableWidgetItem()
+            type_item = QTableWidgetItem()
 
-            filename_item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
-            filename_item.setData(QtCore.Qt.ItemDataRole.UserRole, fi)
+            filename_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
+            filename_item.setData(Qt.UserRole, fi)
             self.twList.setItem(row, FileSelectionList.fileColNum, filename_item)
 
-            folder_item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
+            folder_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
             self.twList.setItem(row, FileSelectionList.folderColNum, folder_item)
 
-            type_item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
+            type_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
             self.twList.setItem(row, FileSelectionList.typeColNum, type_item)
 
-            cix_item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
-            cix_item.setTextAlignment(QtCore.Qt.AlignmentFlag.AlignHCenter)
+            cix_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
+            cix_item.setTextAlignment(Qt.AlignHCenter)
             self.twList.setItem(row, FileSelectionList.CRFlagColNum, cix_item)
 
-            cbi_item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
-            cbi_item.setTextAlignment(QtCore.Qt.AlignmentFlag.AlignHCenter)
+            cbi_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
+            cbi_item.setTextAlignment(Qt.AlignHCenter)
             self.twList.setItem(row, FileSelectionList.CBLFlagColNum, cbi_item)
 
-            readonly_item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
-            readonly_item.setTextAlignment(QtCore.Qt.AlignmentFlag.AlignHCenter)
+            readonly_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
+            readonly_item.setTextAlignment(Qt.AlignHCenter)
             self.twList.setItem(row, FileSelectionList.readonlyColNum, readonly_item)
 
-            self.update_row(row)
+            self.updateRow(row)
 
             return row
-        return -1
 
-    def update_row(self, row: int) -> None:
-        if row >= 0:
-            fi: FileInfo = self.twList.item(row, FileSelectionList.dataColNum).data(QtCore.Qt.ItemDataRole.UserRole)
+    def updateRow(self, row):
+        fi = self.twList.item(row, FileSelectionList.dataColNum).data(Qt.UserRole)  # .toPyObject()
 
-            filename_item = self.twList.item(row, FileSelectionList.fileColNum)
-            folder_item = self.twList.item(row, FileSelectionList.folderColNum)
-            cix_item = self.twList.item(row, FileSelectionList.CRFlagColNum)
-            cbi_item = self.twList.item(row, FileSelectionList.CBLFlagColNum)
-            type_item = self.twList.item(row, FileSelectionList.typeColNum)
-            readonly_item = self.twList.item(row, FileSelectionList.readonlyColNum)
+        filename_item = self.twList.item(row, FileSelectionList.fileColNum)
+        folder_item = self.twList.item(row, FileSelectionList.folderColNum)
+        cix_item = self.twList.item(row, FileSelectionList.CRFlagColNum)
+        cbi_item = self.twList.item(row, FileSelectionList.CBLFlagColNum)
+        type_item = self.twList.item(row, FileSelectionList.typeColNum)
+        readonly_item = self.twList.item(row, FileSelectionList.readonlyColNum)
 
-            item_text = os.path.split(fi.ca.path)[0]
-            folder_item.setText(item_text)
-            folder_item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
+        item_text = os.path.split(fi.ca.path)[0]
+        folder_item.setText(item_text)
+        folder_item.setData(Qt.ToolTipRole, item_text)
 
-            item_text = os.path.split(fi.ca.path)[1]
-            filename_item.setText(item_text)
-            filename_item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
+        item_text = os.path.split(fi.ca.path)[1]
+        filename_item.setText(item_text)
+        filename_item.setData(Qt.ToolTipRole, item_text)
 
-            item_text = fi.ca.archiver.name()
-            type_item.setText(item_text)
-            type_item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
+        if fi.ca.isZip():
+            item_text = "ZIP"
+        elif fi.ca.isRar():
+            item_text = "RAR"
+        elif fi.ca.isTar():
+            item_text = "TAR"
+        else:
+            item_text = ""
+        type_item.setText(item_text)
+        type_item.setData(Qt.ToolTipRole, item_text)
 
-            if fi.ca.has_cix():
-                cix_item.setCheckState(QtCore.Qt.CheckState.Checked)
-                cix_item.setData(QtCore.Qt.ItemDataRole.UserRole, True)
-            else:
-                cix_item.setData(QtCore.Qt.ItemDataRole.UserRole, False)
-                cix_item.setCheckState(QtCore.Qt.CheckState.Unchecked)
+        if fi.ca.hasCIX():
+            cix_item.setCheckState(Qt.Checked)
+            cix_item.setData(Qt.UserRole, True)
+        else:
+            cix_item.setData(Qt.UserRole, False)
+            cix_item.setCheckState(Qt.Unchecked)
 
-            if fi.ca.has_cbi():
-                cbi_item.setCheckState(QtCore.Qt.CheckState.Checked)
-                cbi_item.setData(QtCore.Qt.ItemDataRole.UserRole, True)
-            else:
-                cbi_item.setData(QtCore.Qt.ItemDataRole.UserRole, False)
-                cbi_item.setCheckState(QtCore.Qt.CheckState.Unchecked)
+        if fi.ca.hasCBI():
+            cbi_item.setCheckState(Qt.Checked)
+            cbi_item.setData(Qt.UserRole, True)
+        else:
+            cbi_item.setData(Qt.UserRole, False)
+            cbi_item.setCheckState(Qt.Unchecked)
 
-            if not fi.ca.is_writable():
-                readonly_item.setCheckState(QtCore.Qt.CheckState.Checked)
-                readonly_item.setData(QtCore.Qt.ItemDataRole.UserRole, True)
-            else:
-                readonly_item.setData(QtCore.Qt.ItemDataRole.UserRole, False)
-                readonly_item.setCheckState(QtCore.Qt.CheckState.Unchecked)
+        if not fi.ca.isWritable():
+            readonly_item.setCheckState(Qt.Checked)
+            readonly_item.setData(Qt.UserRole, True)
+        else:
+            readonly_item.setData(Qt.UserRole, False)
+            readonly_item.setCheckState(Qt.Unchecked)
 
-            # Reading these will force them into the ComicArchive's cache
-            try:
-                fi.ca.read_cix()
-            except Exception:
-                pass
-            fi.ca.has_cbi()
+        # Reading these will force them into the ComicArchive's cache
+        fi.ca.readCIX()
+        fi.ca.hasCBI()
 
-    def get_selected_archive_list(self) -> list[ComicArchive]:
-        ca_list: list[ComicArchive] = []
+    def getSelectedArchiveList(self):
+        ca_list = []
         for r in range(self.twList.rowCount()):
             item = self.twList.item(r, FileSelectionList.dataColNum)
             if item.isSelected():
-                fi: FileInfo = item.data(QtCore.Qt.ItemDataRole.UserRole)
+                fi = item.data(Qt.UserRole)
                 ca_list.append(fi.ca)
 
         return ca_list
 
-    def update_current_row(self) -> None:
-        self.update_row(self.twList.currentRow())
+    def updateCurrentRow(self):
+        self.updateRow(self.twList.currentRow())
 
-    def update_selected_rows(self) -> None:
+    def updateSelectedRows(self):
         self.twList.setSortingEnabled(False)
         for r in range(self.twList.rowCount()):
             item = self.twList.item(r, FileSelectionList.dataColNum)
             if item.isSelected():
-                self.update_row(r)
+                self.updateRow(r)
         self.twList.setSortingEnabled(True)
 
-    def current_item_changed_cb(self, curr: QtCore.QModelIndex | None, prev: QtCore.QModelIndex | None) -> None:
-        if curr is not None:
-            new_idx = curr.row()
-            old_idx = -1
-            if prev is not None:
-                old_idx = prev.row()
+    def currentItemChangedCB(self, curr, prev):
 
-            if old_idx == new_idx:
+        new_idx = curr.row()
+        old_idx = -1
+        if prev is not None:
+            old_idx = prev.row()
+        # print("old {0} new {1}".format(old_idx, new_idx))
+
+        if old_idx == new_idx:
+            return
+
+        # don't allow change if modified
+        if prev is not None and new_idx != old_idx:
+            if not self.modifiedFlagVerification("Change Archive", "If you change archives now, data in the form will be lost.  Are you sure?"):
+                self.twList.currentItemChanged.disconnect(self.currentItemChangedCB)
+                self.twList.setCurrentItem(prev)
+                self.twList.currentItemChanged.connect(self.currentItemChangedCB)
+                # Need to defer this revert selection, for some reason
+                QTimer.singleShot(1, self.revertSelection)
                 return
 
-            # don't allow change if modified
-            if prev is not None and new_idx != old_idx:
-                if not self.dirty_flag_verification(
-                    "Change Archive", "If you change archives now, data in the form will be lost.  Are you sure?"
-                ):
-                    self.twList.currentItemChanged.disconnect(self.current_item_changed_cb)
-                    self.twList.setCurrentItem(prev)
-                    self.twList.currentItemChanged.connect(self.current_item_changed_cb)
-                    # Need to defer this revert selection, for some reason
-                    QtCore.QTimer.singleShot(1, self.revert_selection)
-                    return
+        fi = self.twList.item(new_idx, FileSelectionList.dataColNum).data(Qt.UserRole)  # .toPyObject()
+        self.selectionChanged.emit(QVariant(fi))
 
-            fi = self.twList.item(new_idx, FileSelectionList.dataColNum).data(QtCore.Qt.ItemDataRole.UserRole)
-            self.selectionChanged.emit(QtCore.QVariant(fi))
-
-    def revert_selection(self) -> None:
+    def revertSelection(self):
         self.twList.selectRow(self.twList.currentRow())
+
+    def modifiedFlagVerification(self, title, desc):
+        if self.modifiedFlag:
+            reply = QMessageBox.question(self, self.tr(title), self.tr(desc), QMessageBox.Yes, QMessageBox.No)
+
+            if reply != QMessageBox.Yes:
+                return False
+        return True
+
+
+# Attempt to use a special checkbox widget in the cell.
+# Couldn't figure out how to disable it with "enabled" colors
+# w = QWidget()
+# cb = QCheckBox(w)
+# cb.setCheckState(Qt.Checked)
+# layout = QHBoxLayout()
+# layout.addWidget(cb)
+# layout.setAlignment(Qt.AlignHCenter)
+# layout.setMargin(2)
+# w.setLayout(layout)
+# self.twList.setCellWidget(row, 2, w)

comictaggerlib/genericmetadata.py

@@ -0,0 +1 @@
+from comicapi.genericmetadata import *

comictaggerlib/graphics/__init__.py

@@ -1,5 +0,0 @@
-from __future__ import annotations
-
-import pathlib
-
-graphics_path = pathlib.Path(__file__).parent

comictaggerlib/gui.py

@@ -1,143 +0,0 @@
-from __future__ import annotations
-
-import logging.handlers
-import os
-import platform
-import sys
-import traceback
-import types
-
-import settngs
-
-from comictaggerlib.graphics import graphics_path
-from comictalker.comictalker import ComicTalker
-
-logger = logging.getLogger("comictagger")
-try:
-    qt_available = True
-    from PyQt5 import QtCore, QtGui, QtWidgets
-
-    def show_exception_box(log_msg: str) -> None:
-        """Checks if a QApplication instance is available and shows a messagebox with the exception message.
-        If unavailable (non-console application), log an additional notice.
-        """
-        if QtWidgets.QApplication.instance() is not None:
-            errorbox = QtWidgets.QMessageBox()
-            errorbox.setText(log_msg)
-            errorbox.exec()
-            QtWidgets.QApplication.exit(1)
-        else:
-            logger.debug("No QApplication instance available.")
-
-    class UncaughtHook(QtCore.QObject):
-        _exception_caught = QtCore.pyqtSignal(object)
-
-        def __init__(self) -> None:
-            super().__init__()
-
-            # this registers the exception_hook() function as hook with the Python interpreter
-            sys.excepthook = self.exception_hook
-
-            # connect signal to execute the message box function always on main thread
-            self._exception_caught.connect(show_exception_box)
-
-        def exception_hook(
-            self, exc_type: type[BaseException], exc_value: BaseException, exc_traceback: types.TracebackType | None
-        ) -> None:
-            """Function handling uncaught exceptions.
-            It is triggered each time an uncaught exception occurs.
-            """
-            if issubclass(exc_type, KeyboardInterrupt):
-                # ignore keyboard interrupt to support console applications
-                sys.__excepthook__(exc_type, exc_value, exc_traceback)
-            else:
-                exc_info = (exc_type, exc_value, exc_traceback)
-                trace_back = "".join(traceback.format_tb(exc_traceback))
-                log_msg = f"{exc_type.__name__}: {exc_value}\n\n{trace_back}"
-                logger.critical("Uncaught exception: %s: %s", exc_type.__name__, exc_value, exc_info=exc_info)
-
-                # trigger message box show
-                self._exception_caught.emit(f"Oops. An unexpected error occurred:\n{log_msg}")
-
-    qt_exception_hook = UncaughtHook()
-    from comictaggerlib.taggerwindow import TaggerWindow
-
-    class Application(QtWidgets.QApplication):
-        openFileRequest = QtCore.pyqtSignal(QtCore.QUrl, name="openfileRequest")
-
-        # Handles "Open With" from Finder on macOS
-        def event(self, event: QtCore.QEvent) -> bool:
-            if event.type() == QtCore.QEvent.FileOpen:
-                logger.info(event.url().toLocalFile())
-                self.openFileRequest.emit(event.url())
-                return True
-            return super().event(event)
-
-except ImportError:
-
-    def show_exception_box(log_msg: str) -> None:
-        ...
-
-    logger.exception("Qt unavailable")
-    qt_available = False
-
-
-def open_tagger_window(
-    talkers: dict[str, ComicTalker], config: settngs.Config[settngs.Namespace], error: tuple[str, bool] | None
-) -> None:
-    os.environ["QtWidgets.QT_AUTO_SCREEN_SCALE_FACTOR"] = "1"
-    args = []
-    if config[0].runtime_darkmode:
-        args.extend(["-platform", "windows:darkmode=2"])
-    args.extend(sys.argv)
-    app = Application(args)
-    if error is not None:
-        show_exception_box(error[0])
-        if error[1]:
-            raise SystemExit(1)
-
-    # needed to catch initial open file events (macOS)
-    app.openFileRequest.connect(lambda x: config[0].runtime_files.append(x.toLocalFile()))
-
-    if platform.system() == "Darwin":
-        # Set the MacOS dock icon
-        app.setWindowIcon(QtGui.QIcon(str(graphics_path / "app.png")))
-
-    if platform.system() == "Windows":
-        # For pure python, tell windows that we're not python,
-        # so we can have our own taskbar icon
-        import ctypes
-
-        myappid = "comictagger"  # arbitrary string
-        ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)  # type: ignore[attr-defined]
-        # force close of console window
-        swp_hidewindow = 0x0080
-        console_wnd = ctypes.windll.kernel32.GetConsoleWindow()  # type: ignore[attr-defined]
-        if console_wnd != 0:
-            ctypes.windll.user32.SetWindowPos(console_wnd, None, 0, 0, 0, 0, swp_hidewindow)  # type: ignore[attr-defined]
-
-    if platform.system() != "Linux":
-        img = QtGui.QPixmap(str(graphics_path / "tags.png"))
-
-        splash = QtWidgets.QSplashScreen(img)
-        splash.show()
-        splash.raise_()
-        QtWidgets.QApplication.processEvents()
-
-    try:
-        tagger_window = TaggerWindow(config[0].runtime_files, config, talkers)
-        tagger_window.setWindowIcon(QtGui.QIcon(str(graphics_path / "app.png")))
-        tagger_window.show()
-
-        # Catch open file events (macOS)
-        app.openFileRequest.connect(tagger_window.open_file_event)
-
-        if platform.system() != "Linux":
-            splash.finish(tagger_window)
-
-        sys.exit(app.exec())
-    except Exception:
-        logger.exception("GUI mode failed")
-        QtWidgets.QMessageBox.critical(
-            QtWidgets.QMainWindow(), "Error", "Unhandled exception in app:\n" + traceback.format_exc()
-        )

comictaggerlib/imagefetcher.py

@@ -1,72 +1,75 @@
 """A class to manage fetching and caching of images by URL"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
 import datetime
-import logging
 import os
-import pathlib
 import shutil
 import sqlite3 as lite
 import tempfile
 
 import requests
 
-from comictaggerlib import ctversion
+from . import _version
+from .settings import ComicTaggerSettings
 
 try:
-    from PyQt5 import QtCore, QtNetwork
-
-    qt_available = True
+    from PyQt5 import QtGui
+    from PyQt5.QtCore import QByteArray, QObject, QUrl, pyqtSignal
+    from PyQt5.QtNetwork import QNetworkAccessManager, QNetworkRequest
 except ImportError:
-    qt_available = False
+    # No Qt, so define a few dummy QObjects to help us compile
+    class QObject:
+        def __init__(self, *args):
+            pass
 
-logger = logging.getLogger(__name__)
+    class QByteArray:
+        pass
+
+    class pyqtSignal:
+        def __init__(self, *args):
+            pass
+
+        def emit(a, b, c):
+            pass
 
 
 class ImageFetcherException(Exception):
-    ...
+    pass
 
 
-def fetch_complete(image_data: bytes | QtCore.QByteArray) -> None:
-    ...
+class ImageFetcher(QObject):
 
+    fetchComplete = pyqtSignal(QByteArray, int)
 
-class ImageFetcher:
-    image_fetch_complete = fetch_complete
+    def __init__(self):
+        QObject.__init__(self)
 
-    def __init__(self, cache_folder: pathlib.Path) -> None:
-        self.db_file = cache_folder / "image_url_cache.db"
-        self.cache_folder = cache_folder / "image_cache"
-
-        self.user_data = None
-        self.fetched_url = ""
+        self.settings_folder = ComicTaggerSettings.getSettingsFolder()
+        self.db_file = os.path.join(self.settings_folder, "image_url_cache.db")
+        self.cache_folder = os.path.join(self.settings_folder, "image_cache")
 
         if not os.path.exists(self.db_file):
             self.create_image_db()
 
-        if qt_available:
-            self.nam = QtNetwork.QNetworkAccessManager()
-
-    def clear_cache(self) -> None:
+    def clearCache(self):
         os.unlink(self.db_file)
         if os.path.isdir(self.cache_folder):
             shutil.rmtree(self.cache_folder)
 
-    def fetch(self, url: str, blocking: bool = False) -> bytes:
+    def fetch(self, url, user_data=None, blocking=False):
         """
         If called with blocking=True, this will block until the image is
         fetched.
@@ -74,49 +77,52 @@ class ImageFetcher:
         background, and emit a signal when done
         """
 
+        self.user_data = user_data
         self.fetched_url = url
 
         # first look in the DB
         image_data = self.get_image_from_cache(url)
-        # Async for retrieving covers seems to work well
-        if blocking:  # if blocking or not qt_available:
-            if not image_data:
+        if blocking:
+            if image_data is None:
                 try:
-                    image_data = requests.get(url, headers={"user-agent": "comictagger/" + ctversion.version}).content
+                    print(url)
+                    image_data = requests.get(url, headers={"user-agent": "comictagger/" + _version.version}).content
                 except Exception as e:
-                    logger.exception("Fetching url failed: %s")
-                    raise ImageFetcherException("Network Error!") from e
+                    print(e)
+                    raise ImageFetcherException("Network Error!")
 
             # save the image to the cache
             self.add_image_to_cache(self.fetched_url, image_data)
             return image_data
 
-        if qt_available:
+        else:
+
             # if we found it, just emit the signal asap
-            if image_data:
-                ImageFetcher.image_fetch_complete(QtCore.QByteArray(image_data))
-                return b""
+            if image_data is not None:
+                self.fetchComplete.emit(QByteArray(image_data), self.user_data)
+                return
 
             # didn't find it.  look online
-            self.nam.finished.connect(self.finish_request)
-            self.nam.get(QtNetwork.QNetworkRequest(QtCore.QUrl(url)))
+            self.nam = QNetworkAccessManager()
+            self.nam.finished.connect(self.finishRequest)
+            self.nam.get(QNetworkRequest(QUrl(url)))
 
             # we'll get called back when done...
-        return b""
 
-    def finish_request(self, reply: QtNetwork.QNetworkReply) -> None:
+    def finishRequest(self, reply):
+
         # read in the image data
-        logger.debug("request finished")
         image_data = reply.readAll()
 
         # save the image to the cache
         self.add_image_to_cache(self.fetched_url, image_data)
 
-        ImageFetcher.image_fetch_complete(image_data)
+        self.fetchComplete.emit(QByteArray(image_data), self.user_data)
+
+    def create_image_db(self):
 
-    def create_image_db(self) -> None:
         # this will wipe out any existing version
-        open(self.db_file, "wb").close()
+        open(self.db_file, "w").close()
 
         # wipe any existing image cache folder too
         if os.path.isdir(self.cache_folder):
@@ -127,25 +133,30 @@ class ImageFetcher:
 
         # create tables
         with con:
+
             cur = con.cursor()
 
-            cur.execute("CREATE TABLE Images(url TEXT,filename TEXT,timestamp TEXT,PRIMARY KEY (url))")
+            cur.execute("CREATE TABLE Images(" + "url TEXT," + "filename TEXT," + "timestamp TEXT," + "PRIMARY KEY (url))")
+
+    def add_image_to_cache(self, url, image_data):
 
-    def add_image_to_cache(self, url: str, image_data: bytes | QtCore.QByteArray) -> None:
         con = lite.connect(self.db_file)
 
         with con:
+
             cur = con.cursor()
 
             timestamp = datetime.datetime.now()
 
             tmp_fd, filename = tempfile.mkstemp(dir=self.cache_folder, prefix="img")
-            with os.fdopen(tmp_fd, "w+b") as f:
-                f.write(bytes(image_data))
+            f = os.fdopen(tmp_fd, "w+b")
+            f.write(image_data)
+            f.close()
 
             cur.execute("INSERT or REPLACE INTO Images VALUES(?, ?, ?)", (url, filename, timestamp))
 
-    def get_image_from_cache(self, url: str) -> bytes:
+    def get_image_from_cache(self, url):
+
         con = lite.connect(self.db_file)
         with con:
             cur = con.cursor()
@@ -154,16 +165,16 @@ class ImageFetcher:
             row = cur.fetchone()
 
             if row is None:
-                return b""
+                return None
+            else:
+                filename = row[0]
+                image_data = None
 
-            filename = row[0]
-            image_data = b""
+                try:
+                    with open(filename, "rb") as f:
+                        image_data = f.read()
+                        f.close()
+                except IOError as e:
+                    pass
 
-            try:
-                with open(filename, "rb") as f:
-                    image_data = f.read()
-                    f.close()
-            except OSError:
-                pass
-
-            return image_data
+                return image_data

comictaggerlib/imagehasher.py

@@ -1,79 +1,80 @@
 """A class to manage creating image content hashes, and calculate hamming distances"""
-#
-# Copyright 2013 ComicTagger Authors
-#
+
+# Copyright 2013 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
 import io
-import logging
+import sys
 from functools import reduce
-from typing import TypeVar
 
 try:
-    from PIL import Image
+    from PIL import Image, WebPImagePlugin
 
     pil_available = True
 except ImportError:
     pil_available = False
-logger = logging.getLogger(__name__)
 
 
-class ImageHasher:
-    def __init__(self, path: str | None = None, data: bytes = b"", width: int = 8, height: int = 8) -> None:
+class ImageHasher(object):
+    def __init__(self, path=None, data=None, width=8, height=8):
+        # self.hash_size = size
         self.width = width
         self.height = height
 
-        if path is None and not data:
-            raise OSError
+        if path is None and data is None:
+            raise IOError
+        else:
+            try:
+                if path is not None:
+                    self.image = Image.open(path)
+                else:
+                    self.image = Image.open(io.BytesIO(data))
+            except Exception as e:
+                print("Image data seems corrupted! [{}]".format(e))
+                # just generate a bogus image
+                self.image = Image.new("L", (1, 1))
 
+    def average_hash(self):
         try:
-            if path is not None:
-                self.image = Image.open(path)
-            else:
-                self.image = Image.open(io.BytesIO(data))
-        except Exception:
-            logger.exception("Image data seems corrupted!")
-            # just generate a bogus image
-            self.image = Image.new("L", (1, 1))
-
-    def average_hash(self) -> int:
-        try:
-            image = self.image.resize((self.width, self.height), Image.Resampling.LANCZOS).convert("L")
-        except Exception:
-            logger.exception("average_hash error")
-            return 0
+            image = self.image.resize((self.width, self.height), Image.ANTIALIAS).convert("L")
+        except Exception as e:
+            print("average_hash error:", e)
+            return int(0)
 
         pixels = list(image.getdata())
         avg = sum(pixels) / len(pixels)
 
-        def compare_value_to_avg(i: int) -> int:
+        def compare_value_to_avg(i):
             return 1 if i > avg else 0
 
         bitlist = list(map(compare_value_to_avg, pixels))
 
         # build up an int value from the bit list, one bit at a time
-        def set_bit(x: int, idx_val: tuple[int, int]) -> int:
+        def set_bit(x, idx_val):
             (idx, val) = idx_val
             return x | (val << idx)
 
         result = reduce(set_bit, enumerate(bitlist), 0)
 
+        # print("{0:016x}".format(result))
         return result
 
-    def average_hash2(self) -> None:
+    def average_hash2(self):
+        pass
         """
-        # Got this one from somewhere on the net.  Not a clue how the 'convolve2d' works!
+        # Got this one from somewhere on the net.  Not a clue how the 'convolve2d'
+        # works!
 
         from numpy import array
         from scipy.signal import convolve2d
@@ -87,10 +88,12 @@ class ImageHasher:
         result = reduce(lambda x, (y, z): x | (z << y),
                          enumerate(map(lambda i: 0 if i < 0 else 1, filt_data)),
                          0)
+        #print("{0:016x}".format(result))
         return result
         """
 
-    def dct_average_hash(self) -> None:
+    def dct_average_hash(self):
+        pass
         """
         # Algorithm source: http://syntaxcandy.blogspot.com/2012/08/perceptual-hash.html
 
@@ -128,8 +131,8 @@ class ImageHasher:
 
         7. Construct the hash. Set the 64 bits into a 64-bit integer. The order does not
         matter, just as long as you are consistent.
-
-
+        """
+        """
         import numpy
         import scipy.fftpack
         numpy.set_printoptions(threshold=10000, linewidth=200, precision=2, suppress=True)
@@ -164,16 +167,15 @@ class ImageHasher:
         result = reduce(set_bit, enumerate(bitlist), long(0))
 
 
+        #print("{0:016x}".format(result))
         return result
         """
 
     # accepts 2 hashes (longs or hex strings) and returns the hamming distance
 
-    T = TypeVar("T", int, str)
-
     @staticmethod
-    def hamming_distance(h1: T, h2: T) -> int:
-        if isinstance(h1, int) or isinstance(h2, int):
+    def hamming_distance(h1, h2):
+        if isinstance(h1, int) or isinstance(h1, int):
             n1 = h1
             n2 = h2
         else:

comictaggerlib/imagepopup.py

@@ -1,83 +1,70 @@
 """A PyQT4 widget to display a popup image"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import logging
+from PyQt5 import QtCore, QtGui, QtWidgets, uic
 
-from PyQt5 import QtCore, QtGui, QtWidgets, sip, uic
-
-from comictaggerlib.graphics import graphics_path
-from comictaggerlib.ui import ui_path
-
-logger = logging.getLogger(__name__)
+from .settings import ComicTaggerSettings
 
 
 class ImagePopup(QtWidgets.QDialog):
-    def __init__(self, parent: QtWidgets.QWidget, image_pixmap: QtGui.QPixmap) -> None:
-        super().__init__(parent)
+    def __init__(self, parent, image_pixmap):
+        super(ImagePopup, self).__init__(parent)
 
-        uic.loadUi(ui_path / "imagepopup.ui", self)
+        uic.loadUi(ComicTaggerSettings.getUIFile("imagepopup.ui"), self)
 
-        QtWidgets.QApplication.setOverrideCursor(QtGui.QCursor(QtCore.Qt.CursorShape.WaitCursor))
+        QtWidgets.QApplication.setOverrideCursor(QtGui.QCursor(QtCore.Qt.WaitCursor))
 
-        self.setWindowFlags(QtCore.Qt.WindowType.Popup)
-        self.setWindowState(QtCore.Qt.WindowState.WindowFullScreen)
+        # self.setWindowModality(QtCore.Qt.WindowModal)
+        self.setWindowFlags(QtCore.Qt.Popup)
+        self.setWindowState(QtCore.Qt.WindowFullScreen)
 
         self.imagePixmap = image_pixmap
 
-        screen_size = QtGui.QGuiApplication.primaryScreen().geometry()
-        QtWidgets.QApplication.primaryScreen()
+        screen_size = QtWidgets.QDesktopWidget().screenGeometry()
         self.resize(screen_size.width(), screen_size.height())
         self.move(0, 0)
 
         # This is a total hack.  Uses a snapshot of the desktop, and overlays a
-        # translucent screen over it.  Probably can do it better by setting opacity of a widget
-        # TODO: macOS denies this
+        # translucent screen over it.  Probably can do it better by setting opacity of a
+        # widget
         screen = QtWidgets.QApplication.primaryScreen()
-        self.desktopBg = screen.grabWindow(sip.voidptr(0), 0, 0, screen_size.width(), screen_size.height())
-        bg = QtGui.QPixmap(str(graphics_path / "popup_bg.png"))
-        self.clientBgPixmap = bg.scaled(
-            screen_size.width(),
-            screen_size.height(),
-            QtCore.Qt.AspectRatioMode.IgnoreAspectRatio,
-            QtCore.Qt.SmoothTransformation,
-        )
+        self.desktopBg = screen.grabWindow(QtWidgets.QApplication.desktop().winId(), 0, 0, screen_size.width(), screen_size.height())
+        bg = QtGui.QPixmap(ComicTaggerSettings.getGraphic("popup_bg.png"))
+        self.clientBgPixmap = bg.scaled(screen_size.width(), screen_size.height(), QtCore.Qt.IgnoreAspectRatio, QtCore.Qt.SmoothTransformation)
         self.setMask(self.clientBgPixmap.mask())
 
-        self.apply_image_pixmap()
+        self.applyImagePixmap()
         self.showFullScreen()
         self.raise_()
         QtWidgets.QApplication.restoreOverrideCursor()
 
-    def paintEvent(self, event: QtGui.QPaintEvent) -> None:
-        painter = QtGui.QPainter(self)
-        painter.setRenderHint(QtGui.QPainter.RenderHint.Antialiasing)
-        painter.drawPixmap(0, 0, self.desktopBg)
-        painter.drawPixmap(0, 0, self.clientBgPixmap)
-        painter.end()
+    def paintEvent(self, event):
+        self.painter = QtGui.QPainter(self)
+        self.painter.setRenderHint(QtGui.QPainter.Antialiasing)
+        self.painter.drawPixmap(0, 0, self.desktopBg)
+        self.painter.drawPixmap(0, 0, self.clientBgPixmap)
+        self.painter.end()
 
-    def apply_image_pixmap(self) -> None:
+    def applyImagePixmap(self):
         win_h = self.height()
         win_w = self.width()
 
         if self.imagePixmap.width() > win_w or self.imagePixmap.height() > win_h:
             # scale the pixmap to fit in the frame
-            display_pixmap = self.imagePixmap.scaled(
-                win_w, win_h, QtCore.Qt.AspectRatioMode.KeepAspectRatio, QtCore.Qt.SmoothTransformation
-            )
+            display_pixmap = self.imagePixmap.scaled(win_w, win_h, QtCore.Qt.KeepAspectRatio, QtCore.Qt.SmoothTransformation)
             self.lblImage.setPixmap(display_pixmap)
         else:
             display_pixmap = self.imagePixmap
@@ -87,7 +74,7 @@ class ImagePopup(QtWidgets.QDialog):
         img_w = display_pixmap.width()
         img_h = display_pixmap.height()
         self.lblImage.resize(img_w, img_h)
-        self.lblImage.move(int((win_w - img_w) / 2), int((win_h - img_h) / 2))
+        self.lblImage.move((win_w - img_w) / 2, (win_h - img_h) / 2)
 
-    def mousePressEvent(self, event: QtGui.QMouseEvent) -> None:
+    def mousePressEvent(self, event):
         self.close()

comictaggerlib/issueidentifier.py

@@ -1,87 +1,63 @@
 """A class to automatically identify a comic archive"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
 import io
-import logging
 import sys
-from typing import Any, Callable
 
-import settngs
-from typing_extensions import NotRequired, TypedDict
-
-from comicapi import utils
-from comicapi.comicarchive import ComicArchive
-from comicapi.genericmetadata import GenericMetadata
-from comicapi.issuestring import IssueString
-from comictaggerlib.imagefetcher import ImageFetcher, ImageFetcherException
-from comictaggerlib.imagehasher import ImageHasher
-from comictaggerlib.resulttypes import IssueResult
-from comictalker.comictalker import ComicTalker, TalkerError
-
-logger = logging.getLogger(__name__)
+from . import utils
+from .comicvinetalker import ComicVineTalker, ComicVineTalkerException
+from .genericmetadata import GenericMetadata
+from .imagefetcher import ImageFetcher, ImageFetcherException
+from .imagehasher import ImageHasher
+from .issuestring import IssueString
 
 try:
-    from PIL import Image, ImageChops
+    from PIL import Image, WebPImagePlugin
 
     pil_available = True
 except ImportError:
     pil_available = False
 
 
-class SearchKeys(TypedDict):
-    series: str | None
-    issue_number: str | None
-    month: int | None
-    year: int | None
-    issue_count: int | None
-
-
-class Score(TypedDict):
-    score: NotRequired[int]
-    url: str
-    hash: int
-
 
 class IssueIdentifierNetworkError(Exception):
-    ...
+    pass
 
 
 class IssueIdentifierCancelled(Exception):
-    ...
+    pass
 
 
 class IssueIdentifier:
-    result_no_matches = 0
-    result_found_match_but_bad_cover_score = 1
-    result_found_match_but_not_first_page = 2
-    result_multiple_matches_with_bad_image_scores = 3
-    result_one_good_match = 4
-    result_multiple_good_matches = 5
 
-    def __init__(self, comic_archive: ComicArchive, config: settngs.Namespace, talker: ComicTalker) -> None:
-        self.config = config
-        self.talker = talker
-        self.comic_archive: ComicArchive = comic_archive
+    ResultNoMatches = 0
+    ResultFoundMatchButBadCoverScore = 1
+    ResultFoundMatchButNotFirstPage = 2
+    ResultMultipleMatchesWithBadImageScores = 3
+    ResultOneGoodMatch = 4
+    ResultMultipleGoodMatches = 5
+
+    def __init__(self, comic_archive, settings):
+        self.comic_archive = comic_archive
         self.image_hasher = 1
 
-        self.only_use_additional_meta_data = False
+        self.onlyUseAdditionalMetaData = False
 
         # a decent hamming score, good enough to call it a match
-        self.min_score_thresh: int = 16
+        self.min_score_thresh = 16
 
         # for alternate covers, be more stringent, since we're a bit more
         # scattershot in comparisons
@@ -96,304 +72,297 @@ class IssueIdentifier:
 
         # used to eliminate series names that are too long based on our search
         # string
-        self.series_match_thresh = config.identifier_series_match_identify_thresh
+        self.length_delta_thresh = settings.id_length_delta_thresh
 
         # used to eliminate unlikely publishers
-        self.publisher_filter = [s.strip().casefold() for s in config.identifier_publisher_filter]
+        self.publisher_blacklist = [s.strip().lower() for s in settings.id_publisher_blacklist.split(",")]
 
         self.additional_metadata = GenericMetadata()
-        self.output_function: Callable[[str], None] = IssueIdentifier.default_write_output
-        self.callback: Callable[[int, int], None] | None = None
-        self.cover_url_callback: Callable[[bytes], None] | None = None
-        self.search_result = self.result_no_matches
+        self.output_function = IssueIdentifier.defaultWriteOutput
+        self.callback = None
+        self.coverUrlCallback = None
+        self.search_result = self.ResultNoMatches
         self.cover_page_index = 0
         self.cancel = False
+        self.waitAndRetryOnRateLimit = False
 
-        self.match_list: list[IssueResult] = []
-
-    def set_score_min_threshold(self, thresh: int) -> None:
+    def setScoreMinThreshold(self, thresh):
         self.min_score_thresh = thresh
 
-    def set_score_min_distance(self, distance: int) -> None:
+    def setScoreMinDistance(self, distance):
         self.min_score_distance = distance
 
-    def set_additional_metadata(self, md: GenericMetadata) -> None:
+    def setAdditionalMetadata(self, md):
         self.additional_metadata = md
 
-    def set_name_series_match_threshold(self, delta: int) -> None:
-        self.series_match_thresh = delta
+    def setNameLengthDeltaThreshold(self, delta):
+        self.length_delta_thresh = delta
 
-    def set_publisher_filter(self, flt: list[str]) -> None:
-        self.publisher_filter = flt
+    def setPublisherBlackList(self, blacklist):
+        self.publisher_blacklist = blacklist
 
-    def set_hasher_algorithm(self, algo: int) -> None:
+    def setHasherAlgorithm(self, algo):
         self.image_hasher = algo
+        pass
 
-    def set_output_function(self, func: Callable[[str], None]) -> None:
+    def setOutputFunction(self, func):
         self.output_function = func
+        pass
 
-    def calculate_hash(self, image_data: bytes) -> int:
-        if self.image_hasher == 3:
-            return -1  # ImageHasher(data=image_data).dct_average_hash()
-        if self.image_hasher == 2:
-            return -1  # ImageHasher(data=image_data).average_hash2()
+    def calculateHash(self, image_data):
+        if self.image_hasher == "3":
+            return ImageHasher(data=image_data).dct_average_hash()
+        elif self.image_hasher == "2":
+            return ImageHasher(data=image_data).average_hash2()
+        else:
+            return ImageHasher(data=image_data).average_hash()
 
-        return ImageHasher(data=image_data).average_hash()
-
-    def get_aspect_ratio(self, image_data: bytes) -> float:
+    def getAspectRatio(self, image_data):
         try:
-            im = Image.open(io.BytesIO(image_data))
+            im = Image.open(io.StringIO(image_data))
             w, h = im.size
             return float(h) / float(w)
-        except Exception:
+        except:
             return 1.5
 
-    def crop_cover(self, image_data: bytes) -> bytes:
-        im = Image.open(io.BytesIO(image_data))
+    def cropCover(self, image_data):
+
+        im = Image.open(io.StringIO(image_data))
         w, h = im.size
 
         try:
             cropped_im = im.crop((int(w / 2), 0, w, h))
-        except Exception:
-            logger.exception("cropCover() error")
-            return b""
+        except Exception as e:
+            print("cropCover() error:", e)
+            return None
 
-        output = io.BytesIO()
-        cropped_im.convert("RGB").save(output, format="PNG")
+        output = io.StringIO()
+        cropped_im.save(output, format="PNG")
         cropped_image_data = output.getvalue()
         output.close()
 
         return cropped_image_data
 
-    # Adapted from https://stackoverflow.com/a/10616717/20629671
-    def crop_border(self, image_data: bytes, ratio: int) -> bytes | None:
-        im = Image.open(io.BytesIO(image_data))
-
-        # RGBA doesn't work????
-        tmp = im.convert("RGB")
-
-        bg = Image.new("RGB", tmp.size, "black")
-        diff = ImageChops.difference(tmp, bg)
-        diff = ImageChops.add(diff, diff, 2.0, -100)
-
-        bbox = diff.getbbox()
-
-        width_percent = 0
-        height_percent = 0
-
-        # If bbox is None that should mean it's solid black
-        if bbox:
-            width = bbox[2] - bbox[0]
-            height = bbox[3] - bbox[1]
-
-            # Convert to percent
-            width_percent = int(100 - ((width / im.width) * 100))
-            height_percent = int(100 - ((height / im.height) * 100))
-            logger.debug(
-                "Width: %s Height: %s, ratio: %s  %s ratio met: %s",
-                im.width,
-                im.height,
-                width_percent,
-                height_percent,
-                width_percent > ratio or height_percent > ratio,
-            )
-
-        # If there is a difference return the image otherwise return None
-        if width_percent > ratio or height_percent > ratio:
-            output = io.BytesIO()
-            im.crop(bbox).save(output, format="PNG")
-            cropped_image_data = output.getvalue()
-            output.close()
-            return cropped_image_data
-        return None
-
-    def set_progress_callback(self, cb_func: Callable[[int, int], None]) -> None:
+    def setProgressCallback(self, cb_func):
         self.callback = cb_func
 
-    def set_cover_url_callback(self, cb_func: Callable[[bytes], None]) -> None:
-        self.cover_url_callback = cb_func
+    def setCoverURLCallback(self, cb_func):
+        self.coverUrlCallback = cb_func
+
+    def getSearchKeys(self):
 
-    def get_search_keys(self) -> SearchKeys:
         ca = self.comic_archive
+        search_keys = dict()
+        search_keys["series"] = None
+        search_keys["issue_number"] = None
+        search_keys["month"] = None
+        search_keys["year"] = None
+        search_keys["issue_count"] = None
 
-        search_keys: SearchKeys
-        if self.only_use_additional_meta_data:
-            search_keys = SearchKeys(
-                series=self.additional_metadata.series,
-                issue_number=self.additional_metadata.issue,
-                year=self.additional_metadata.year,
-                month=self.additional_metadata.month,
-                issue_count=self.additional_metadata.issue_count,
-            )
+        if ca is None:
+            return
+
+        if self.onlyUseAdditionalMetaData:
+            search_keys["series"] = self.additional_metadata.series
+            search_keys["issue_number"] = self.additional_metadata.issue
+            search_keys["year"] = self.additional_metadata.year
+            search_keys["month"] = self.additional_metadata.month
+            search_keys["issue_count"] = self.additional_metadata.issueCount
             return search_keys
 
         # see if the archive has any useful meta data for searching with
-        try:
-            if ca.has_cix():
-                internal_metadata = ca.read_cix()
-            else:
-                internal_metadata = ca.read_cbi()
-        except Exception as e:
-            internal_metadata = GenericMetadata()
-            logger.error("Failed to load metadata for %s: %s", ca.path, e)
+        if ca.hasCIX():
+            internal_metadata = ca.readCIX()
+        elif ca.hasCBI():
+            internal_metadata = ca.readCBI()
+        else:
+            internal_metadata = ca.readCBI()
 
         # try to get some metadata from filename
-        md_from_filename = ca.metadata_from_filename(
-            self.config.filename_complicated_parser,
-            self.config.filename_remove_c2c,
-            self.config.filename_remove_fcbd,
-            self.config.filename_remove_publisher,
-        )
-
-        working_md = md_from_filename.copy()
-
-        working_md.overlay(internal_metadata)
-        working_md.overlay(self.additional_metadata)
+        md_from_filename = ca.metadataFromFilename()
 
         # preference order:
         # 1. Additional metadata
         # 1. Internal metadata
         # 1. Filename metadata
-        search_keys = SearchKeys(
-            series=working_md.series,
-            issue_number=working_md.issue,
-            year=working_md.year,
-            month=working_md.month,
-            issue_count=working_md.issue_count,
-        )
+
+        if self.additional_metadata.series is not None:
+            search_keys["series"] = self.additional_metadata.series
+        elif internal_metadata.series is not None:
+            search_keys["series"] = internal_metadata.series
+        else:
+            search_keys["series"] = md_from_filename.series
+
+        if self.additional_metadata.issue is not None:
+            search_keys["issue_number"] = self.additional_metadata.issue
+        elif internal_metadata.issue is not None:
+            search_keys["issue_number"] = internal_metadata.issue
+        else:
+            search_keys["issue_number"] = md_from_filename.issue
+
+        if self.additional_metadata.year is not None:
+            search_keys["year"] = self.additional_metadata.year
+        elif internal_metadata.year is not None:
+            search_keys["year"] = internal_metadata.year
+        else:
+            search_keys["year"] = md_from_filename.year
+
+        if self.additional_metadata.month is not None:
+            search_keys["month"] = self.additional_metadata.month
+        elif internal_metadata.month is not None:
+            search_keys["month"] = internal_metadata.month
+        else:
+            search_keys["month"] = md_from_filename.month
+
+        if self.additional_metadata.issueCount is not None:
+            search_keys["issue_count"] = self.additional_metadata.issueCount
+        elif internal_metadata.issueCount is not None:
+            search_keys["issue_count"] = internal_metadata.issueCount
+        else:
+            search_keys["issue_count"] = md_from_filename.issueCount
 
         return search_keys
 
     @staticmethod
-    def default_write_output(text: str) -> None:
+    def defaultWriteOutput(text):
         sys.stdout.write(text)
         sys.stdout.flush()
 
-    def log_msg(self, msg: Any, newline: bool = True) -> None:
-        msg = str(msg)
-        if newline:
-            msg += "\n"
+    def log_msg(self, msg, newline=True):
         self.output_function(msg)
+        if newline:
+            self.output_function("\n")
 
-    def get_issue_cover_match_score(
-        self,
-        issue_id: str,
-        primary_img_url: str,
-        alt_urls: list[str],
-        local_cover_hash_list: list[int],
-        use_remote_alternates: bool = False,
-        use_log: bool = True,
-    ) -> Score:
-        # local_cover_hash_list is a list of pre-calculated hashes.
-        # use_remote_alternates - indicates to use alternate covers from CV
-
-        # If there is no URL return 0
-        if not primary_img_url:
-            return Score(score=0, url="", hash=0)
+    def getIssueCoverMatchScore(
+        self, comicVine, issue_id, primary_img_url, primary_thumb_url, page_url, localCoverHashList, useRemoteAlternates=False, useLog=True
+    ):
+        # localHashes is a list of pre-calculated hashs.
+        # useRemoteAlternates - indicates to use alternate covers from CV
 
         try:
-            url_image_data = ImageFetcher(self.config.runtime_config.user_cache_dir).fetch(
-                primary_img_url, blocking=True
-            )
-        except ImageFetcherException as e:
+            url_image_data = ImageFetcher().fetch(primary_thumb_url, blocking=True)
+        except ImageFetcherException:
             self.log_msg("Network issue while fetching cover image from Comic Vine. Aborting...")
-            raise IssueIdentifierNetworkError from e
+            raise IssueIdentifierNetworkError
 
         if self.cancel:
             raise IssueIdentifierCancelled
 
         # alert the GUI, if needed
-        if self.cover_url_callback is not None:
-            self.cover_url_callback(url_image_data)
+        if self.coverUrlCallback is not None:
+            self.coverUrlCallback(url_image_data)
 
-        remote_cover_list = [Score(url=primary_img_url, hash=self.calculate_hash(url_image_data))]
+        remote_cover_list = []
+        item = dict()
+        item["url"] = primary_img_url
+
+        item["hash"] = self.calculateHash(url_image_data)
+        remote_cover_list.append(item)
 
         if self.cancel:
             raise IssueIdentifierCancelled
 
-        if use_remote_alternates:
-            for alt_url in alt_urls:
+        if useRemoteAlternates:
+            alt_img_url_list = comicVine.fetchAlternateCoverURLs(issue_id, page_url)
+            for alt_url in alt_img_url_list:
                 try:
-                    alt_url_image_data = ImageFetcher(self.config.runtime_config.user_cache_dir).fetch(
-                        alt_url, blocking=True
-                    )
-                except ImageFetcherException as e:
+                    alt_url_image_data = ImageFetcher().fetch(alt_url, blocking=True)
+                except ImageFetcherException:
                     self.log_msg("Network issue while fetching alt. cover image from Comic Vine. Aborting...")
-                    raise IssueIdentifierNetworkError from e
+                    raise IssueIdentifierNetworkError
 
                 if self.cancel:
                     raise IssueIdentifierCancelled
 
                 # alert the GUI, if needed
-                if self.cover_url_callback is not None:
-                    self.cover_url_callback(alt_url_image_data)
+                if self.coverUrlCallback is not None:
+                    self.coverUrlCallback(alt_url_image_data)
 
-                remote_cover_list.append(Score(url=alt_url, hash=self.calculate_hash(alt_url_image_data)))
+                item = dict()
+                item["url"] = alt_url
+                item["hash"] = self.calculateHash(alt_url_image_data)
+                remote_cover_list.append(item)
 
                 if self.cancel:
                     raise IssueIdentifierCancelled
 
-        if use_log and use_remote_alternates:
-            self.log_msg(f"[{len(remote_cover_list) - 1} alt. covers]", False)
-        if use_log:
+        if useLog and useRemoteAlternates:
+            self.log_msg("[{0} alt. covers]".format(len(remote_cover_list) - 1), False)
+        if useLog:
             self.log_msg("[ ", False)
 
         score_list = []
         done = False
-        for local_cover_hash in local_cover_hash_list:
+        for local_cover_hash in localCoverHashList:
             for remote_cover_item in remote_cover_list:
                 score = ImageHasher.hamming_distance(local_cover_hash, remote_cover_item["hash"])
-                score_list.append(Score(score=score, url=remote_cover_item["url"], hash=remote_cover_item["hash"]))
-                if use_log:
-                    self.log_msg(score, False)
+                score_item = dict()
+                score_item["score"] = score
+                score_item["url"] = remote_cover_item["url"]
+                score_item["hash"] = remote_cover_item["hash"]
+                score_list.append(score_item)
+                if useLog:
+                    self.log_msg("{0}".format(score), False)
 
                 if score <= self.strong_score_thresh:
-                    # such a good score, we can quit now, since for sure we have a winner
+                    # such a good score, we can quit now, since for sure we
+                    # have a winner
                     done = True
                     break
             if done:
                 break
 
-        if use_log:
+        if useLog:
             self.log_msg(" ]", False)
 
         best_score_item = min(score_list, key=lambda x: x["score"])
 
         return best_score_item
 
-    def search(self) -> list[IssueResult]:
+    # def validate(self, issue_id):
+    # create hash list
+    #    score = self.getIssueMatchScore(issue_id, hash_list, useRemoteAlternates = True)
+    #    if score < 20:
+    #        return True
+    #    else:
+    #        return False
+
+    def search(self):
+
         ca = self.comic_archive
         self.match_list = []
         self.cancel = False
-        self.search_result = self.result_no_matches
+        self.search_result = self.ResultNoMatches
 
         if not pil_available:
             self.log_msg("Python Imaging Library (PIL) is not available and is needed for issue identification.")
             return self.match_list
 
-        if not ca.seems_to_be_a_comic_archive():
-            self.log_msg(f"Sorry, but {ca.path} is not a comic archive!")
+        if not ca.seemsToBeAComicArchive():
+            self.log_msg("Sorry, but " + opts.filename + " is not a comic archive!")
             return self.match_list
 
-        cover_image_data = ca.get_page(self.cover_page_index)
-        cover_hash = self.calculate_hash(cover_image_data)
+        cover_image_data = ca.getPage(self.cover_page_index)
+        cover_hash = self.calculateHash(cover_image_data)
 
         # check the aspect ratio
         # if it's wider than it is high, it's probably a two page spread
         # if so, crop it and calculate a second hash
         narrow_cover_hash = None
-        aspect_ratio = self.get_aspect_ratio(cover_image_data)
+        aspect_ratio = self.getAspectRatio(cover_image_data)
         if aspect_ratio < 1.0:
-            right_side_image_data = self.crop_cover(cover_image_data)
+            right_side_image_data = self.cropCover(cover_image_data)
             if right_side_image_data is not None:
-                narrow_cover_hash = self.calculate_hash(right_side_image_data)
+                narrow_cover_hash = self.calculateHash(right_side_image_data)
 
-        keys = self.get_search_keys()
-        # normalize the issue number, None will return as ""
-        keys["issue_number"] = IssueString(keys["issue_number"]).as_string()
+        # self.log_msg("Cover hash = {0:016x}".format(cover_hash))
+
+        keys = self.getSearchKeys()
+        # normalize the issue number
+        keys["issue_number"] = IssueString(keys["issue_number"]).asString()
 
         # we need, at minimum, a series and issue number
-        if not (keys["series"] and keys["issue_number"]):
+        if keys["series"] is None or keys["issue_number"] is None:
             self.log_msg("Not enough info for a search!")
             return []
 
@@ -407,39 +376,51 @@ class IssueIdentifier:
         if keys["month"] is not None:
             self.log_msg("\tMonth:  " + str(keys["month"]))
 
-        self.log_msg(f"Searching for {keys['series']} #{keys['issue_number']} ...")
+        # self.log_msg("Publisher Blacklist: " + str(self.publisher_blacklist))
+        comicVine = ComicVineTalker()
+        comicVine.wait_for_rate_limit = self.waitAndRetryOnRateLimit
+
+        comicVine.setLogFunc(self.output_function)
+
+        # self.log_msg(("Searching for " + keys['series'] + "...")
+        self.log_msg("Searching for  {0} #{1} ...".format(keys["series"], keys["issue_number"]))
         try:
-            ct_search_results = self.talker.search_for_series(keys["series"])
-        except TalkerError as e:
-            self.log_msg(f"Error searching for series.\n{e}")
+            cv_search_results = comicVine.searchForSeries(keys["series"])
+        except ComicVineTalkerException:
+            self.log_msg("Network issue while searching for series. Aborting...")
             return []
 
+        # self.log_msg("Found " + str(len(cv_search_results)) + " initial results")
         if self.cancel:
             return []
 
-        if ct_search_results is None:
+        if cv_search_results is None:
             return []
 
         series_second_round_list = []
 
-        for item in ct_search_results:
+        # self.log_msg("Removing results with too long names, banned publishers, or future start dates")
+        for item in cv_search_results:
             length_approved = False
             publisher_approved = True
             date_approved = True
 
             # remove any series that starts after the issue year
-            if keys["year"] is not None and item.start_year is not None:
-                if keys["year"] < item.start_year:
+            if keys["year"] is not None and str(keys["year"]).isdigit() and item["start_year"] is not None and str(item["start_year"]).isdigit():
+                if int(keys["year"]) < int(item["start_year"]):
                     date_approved = False
 
-            for name in [item.name, *item.aliases]:
-                if utils.titles_match(keys["series"], name, self.series_match_thresh):
-                    length_approved = True
-                    break
-            # remove any series from publishers on the filter
-            if item.publisher is not None:
-                publisher = item.publisher
-                if publisher is not None and publisher.casefold() in self.publisher_filter:
+            # assume that our search name is close to the actual name, say
+            # within ,e.g. 5 chars
+            shortened_key = utils.removearticles(keys["series"])
+            shortened_item_name = utils.removearticles(item["name"])
+            if len(shortened_item_name) < (len(shortened_key) + self.length_delta_thresh):
+                length_approved = True
+
+            # remove any series from publishers on the blacklist
+            if item["publisher"] is not None:
+                publisher = item["publisher"]["name"]
+                if publisher is not None and publisher.lower() in self.publisher_blacklist:
                     publisher_approved = False
 
             if length_approved and publisher_approved and date_approved:
@@ -451,38 +432,37 @@ class IssueIdentifier:
             self.callback(0, len(series_second_round_list))
 
         # now sort the list by name length
-        series_second_round_list.sort(key=lambda x: len(x.name), reverse=False)
+        series_second_round_list.sort(key=lambda x: len(x["name"]), reverse=False)
 
-        series_by_id = {series.id: series for series in series_second_round_list}
+        # build a list of volume IDs
+        volume_id_list = list()
+        for series in series_second_round_list:
+            volume_id_list.append(series["id"])
 
-        issue_list = None
         try:
-            if len(series_by_id) > 0:
-                issue_list = self.talker.fetch_issues_by_series_issue_num_and_year(
-                    list(series_by_id.keys()), keys["issue_number"], keys["year"]
-                )
-        except TalkerError as e:
-            self.log_msg(f"Issue with while searching for series details. Aborting...\n{e}")
+            issue_list = comicVine.fetchIssuesByVolumeIssueNumAndYear(volume_id_list, keys["issue_number"], keys["year"])
+
+        except ComicVineTalkerException:
+            self.log_msg("Network issue while searching for series details. Aborting...")
             return []
 
         if issue_list is None:
             return []
 
-        shortlist = []
-        # now re-associate the issues and series
-        # is this really needed?
+        shortlist = list()
+        # now re-associate the issues and volumes
         for issue in issue_list:
-            if issue.series.id in series_by_id:
-                shortlist.append((series_by_id[issue.series.id], issue))
+            for series in series_second_round_list:
+                if series["id"] == issue["volume"]["id"]:
+                    shortlist.append((series, issue))
+                    break
 
         if keys["year"] is None:
-            self.log_msg(f"Found {len(shortlist)} series that have an issue #{keys['issue_number']}")
+            self.log_msg("Found {0} series that have an issue #{1}".format(len(shortlist), keys["issue_number"]))
         else:
-            self.log_msg(
-                f"Found {len(shortlist)} series that have an issue #{keys['issue_number']} from {keys['year']}"
-            )
+            self.log_msg("Found {0} series that have an issue #{1} from {2}".format(len(shortlist), keys["issue_number"], keys["year"]))
 
-        # now we have a shortlist of series with the desired issue number
+        # now we have a shortlist of volumes with the desired issue number
         # Do first round of cover matching
         counter = len(shortlist)
         for series, issue in shortlist:
@@ -490,100 +470,88 @@ class IssueIdentifier:
                 self.callback(counter, len(shortlist) * 3)
                 counter += 1
 
-            self.log_msg(
-                f"Examining covers for  ID: {series.id} {series.name} ({series.start_year}) ...",
-                newline=False,
-            )
+            self.log_msg("Examining covers for  ID: {0} {1} ({2}) ...".format(series["id"], series["name"], series["start_year"]), newline=False)
 
             # parse out the cover date
-            _, month, year = utils.parse_date_str(issue.cover_date)
+            day, month, year = comicVine.parseDateStr(issue["cover_date"])
 
             # Now check the cover match against the primary image
             hash_list = [cover_hash]
             if narrow_cover_hash is not None:
                 hash_list.append(narrow_cover_hash)
 
-            cropped_border = self.crop_border(cover_image_data, self.config.identifier_border_crop_percent)
-            if cropped_border is not None:
-                hash_list.append(self.calculate_hash(cropped_border))
-                logger.info("Adding cropped cover to the hashlist")
-
             try:
-                image_url = issue.image_url
-                alt_urls = issue.alt_image_urls
+                image_url = issue["image"]["super_url"]
+                thumb_url = issue["image"]["thumb_url"]
+                page_url = issue["site_detail_url"]
 
-                score_item = self.get_issue_cover_match_score(
-                    issue.id, image_url, alt_urls, hash_list, use_remote_alternates=False
+                score_item = self.getIssueCoverMatchScore(
+                    comicVine, issue["id"], image_url, thumb_url, page_url, hash_list, useRemoteAlternates=False
                 )
-            except Exception:
-                logger.exception("Scoring series failed")
+            except:
                 self.match_list = []
                 return self.match_list
 
-            match: IssueResult = {
-                "series": f"{series.name} ({series.start_year})",
-                "distance": score_item["score"],
-                "issue_number": keys["issue_number"],
-                "cv_issue_count": series.count_of_issues,
-                "url_image_hash": score_item["hash"],
-                "issue_title": issue.name,
-                "issue_id": issue.id,
-                "series_id": series.id,
-                "month": month,
-                "year": year,
-                "publisher": None,
-                "image_url": image_url,
-                "alt_image_urls": alt_urls,
-                "description": issue.description,
-            }
-            if series.publisher is not None:
-                match["publisher"] = series.publisher
+            match = dict()
+            match["series"] = "{0} ({1})".format(series["name"], series["start_year"])
+            match["distance"] = score_item["score"]
+            match["issue_number"] = keys["issue_number"]
+            match["cv_issue_count"] = series["count_of_issues"]
+            match["url_image_hash"] = score_item["hash"]
+            match["issue_title"] = issue["name"]
+            match["issue_id"] = issue["id"]
+            match["volume_id"] = series["id"]
+            match["month"] = month
+            match["year"] = year
+            match["publisher"] = None
+            if series["publisher"] is not None:
+                match["publisher"] = series["publisher"]["name"]
+            match["image_url"] = image_url
+            match["thumb_url"] = thumb_url
+            match["page_url"] = page_url
+            match["description"] = issue["description"]
 
             self.match_list.append(match)
 
-            self.log_msg(f" --> {match['distance']}", newline=False)
+            self.log_msg(" --> {0}".format(match["distance"]), newline=False)
 
             self.log_msg("")
 
         if len(self.match_list) == 0:
-            self.log_msg(":-( no matches!")
-            self.search_result = self.result_no_matches
+            self.log_msg(":-(no matches!")
+            self.search_result = self.ResultNoMatches
             return self.match_list
 
         # sort list by image match scores
         self.match_list.sort(key=lambda k: k["distance"])
 
-        lst = []
+        l = []
         for i in self.match_list:
-            lst.append(i["distance"])
+            l.append(i["distance"])
 
-        self.log_msg(f"Compared to covers in {len(self.match_list)} issue(s):", newline=False)
-        self.log_msg(str(lst))
+        self.log_msg("Compared to covers in {0} issue(s):".format(len(self.match_list)), newline=False)
+        self.log_msg(str(l))
 
-        def print_match(item: IssueResult) -> None:
+        def print_match(item):
             self.log_msg(
-                "-----> {} #{} {} ({}/{}) -- score: {}".format(
-                    item["series"],
-                    item["issue_number"],
-                    item["issue_title"],
-                    item["month"],
-                    item["year"],
-                    item["distance"],
+                "-----> {0} #{1} {2} ({3}/{4}) -- score: {5}".format(
+                    item["series"], item["issue_number"], item["issue_title"], item["month"], item["year"], item["distance"]
                 )
             )
 
-        best_score: int = self.match_list[0]["distance"]
+        best_score = self.match_list[0]["distance"]
 
         if best_score >= self.min_score_thresh:
             # we have 1 or more low-confidence matches (all bad cover scores)
-            # look at a few more pages in the archive, and also alternate covers online
+            # look at a few more pages in the archive, and also alternate
+            # covers online
             self.log_msg("Very weak scores for the cover. Analyzing alternate pages and covers...")
             hash_list = [cover_hash]
             if narrow_cover_hash is not None:
                 hash_list.append(narrow_cover_hash)
-            for page_index in range(1, min(3, ca.get_number_of_pages())):
-                image_data = ca.get_page(page_index)
-                page_hash = self.calculate_hash(image_data)
+            for i in range(1, min(3, ca.getNumberOfPages())):
+                image_data = ca.getPage(i)
+                page_hash = self.calculateHash(image_data)
                 hash_list.append(page_hash)
 
             second_match_list = []
@@ -592,20 +560,15 @@ class IssueIdentifier:
                 if self.callback is not None:
                     self.callback(counter, len(self.match_list) * 3)
                     counter += 1
-                self.log_msg(f"Examining alternate covers for ID: {m['series_id']} {m['series']} ...", newline=False)
+                self.log_msg("Examining alternate covers for ID: {0} {1} ...".format(m["volume_id"], m["series"]), newline=False)
                 try:
-                    score_item = self.get_issue_cover_match_score(
-                        m["issue_id"],
-                        m["image_url"],
-                        m["alt_image_urls"],
-                        hash_list,
-                        use_remote_alternates=True,
+                    score_item = self.getIssueCoverMatchScore(
+                        comicVine, m["issue_id"], m["image_url"], m["thumb_url"], m["page_url"], hash_list, useRemoteAlternates=True
                     )
-                except Exception:
-                    logger.exception("failed examining alt covers")
+                except:
                     self.match_list = []
                     return self.match_list
-                self.log_msg(f"--->{score_item['score']}")
+                self.log_msg("--->{0}".format(score_item["score"]))
                 self.log_msg("")
 
                 if score_item["score"] < self.min_alternate_score_thresh:
@@ -618,43 +581,43 @@ class IssueIdentifier:
                     self.log_msg("--------------------------------------------------------------------------")
                     print_match(self.match_list[0])
                     self.log_msg("--------------------------------------------------------------------------")
-                    self.search_result = self.result_found_match_but_bad_cover_score
+                    self.search_result = self.ResultFoundMatchButBadCoverScore
                 else:
                     self.log_msg("--------------------------------------------------------------------------")
                     self.log_msg("Multiple bad cover matches!  Need to use other info...")
                     self.log_msg("--------------------------------------------------------------------------")
-                    self.search_result = self.result_multiple_matches_with_bad_image_scores
+                    self.search_result = self.ResultMultipleMatchesWithBadImageScores
                 return self.match_list
+            else:
+                # We did good, found something!
+                self.log_msg("Success in secondary/alternate cover matching!")
 
-            # We did good, found something!
-            self.log_msg("Success in secondary/alternate cover matching!")
-
-            self.match_list = second_match_list
-            # sort new list by image match scores
-            self.match_list.sort(key=lambda k: k["distance"])
-            best_score = self.match_list[0]["distance"]
-            self.log_msg("[Second round cover matching: best score = {best_score}]")
-            # now drop down into the rest of the processing
+                self.match_list = second_match_list
+                # sort new list by image match scores
+                self.match_list.sort(key=lambda k: k["distance"])
+                best_score = self.match_list[0]["distance"]
+                self.log_msg("[Second round cover matching: best score = {0}]".format(best_score))
+                # now drop down into the rest of the processing
 
         if self.callback is not None:
             self.callback(99, 100)
 
-        # now pare down list, remove any item more than specified distant from the top scores
-        for match_item in reversed(self.match_list):
-            if match_item["distance"] > best_score + self.min_score_distance:
-                self.match_list.remove(match_item)
+        # now pare down list, remove any item more than specified distant from
+        # the top scores
+        for item in reversed(self.match_list):
+            if item["distance"] > best_score + self.min_score_distance:
+                self.match_list.remove(item)
 
         # One more test for the case choosing limited series first issue vs a trade with the same cover:
-        # if we have a given issue count > 1 and the series from CV has count==1, remove it from match list
+        # if we have a given issue count > 1 and the volume from CV has
+        # count==1, remove it from match list
         if len(self.match_list) >= 2 and keys["issue_count"] is not None and keys["issue_count"] != 1:
-            new_list = []
+            new_list = list()
             for match in self.match_list:
                 if match["cv_issue_count"] != 1:
                     new_list.append(match)
                 else:
-                    self.log_msg(
-                        f"Removing series {match['series']} [{match['series_id']}] from consideration (only 1 issue)"
-                    )
+                    self.log_msg("Removing volume {0} [{1}] from consideration (only 1 issue)".format(match["series"], match["volume_id"]))
 
             if len(new_list) > 0:
                 self.match_list = new_list
@@ -663,20 +626,20 @@ class IssueIdentifier:
             self.log_msg("--------------------------------------------------------------------------")
             print_match(self.match_list[0])
             self.log_msg("--------------------------------------------------------------------------")
-            self.search_result = self.result_one_good_match
+            self.search_result = self.ResultOneGoodMatch
 
         elif len(self.match_list) == 0:
             self.log_msg("--------------------------------------------------------------------------")
             self.log_msg("No matches found :(")
             self.log_msg("--------------------------------------------------------------------------")
-            self.search_result = self.result_no_matches
+            self.search_result = self.ResultNoMatches
         else:
             # we've got multiple good matches:
             self.log_msg("More than one likely candidate.")
-            self.search_result = self.result_multiple_good_matches
+            self.search_result = self.ResultMultipleGoodMatches
             self.log_msg("--------------------------------------------------------------------------")
-            for match_item in self.match_list:
-                print_match(match_item)
+            for item in self.match_list:
+                print_match(item)
             self.log_msg("--------------------------------------------------------------------------")
 
         return self.match_list

comictaggerlib/issueselectionwindow.py

@@ -1,108 +1,71 @@
 """A PyQT4 dialog to select specific issue from list"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import logging
 
-import settngs
 from PyQt5 import QtCore, QtGui, QtWidgets, uic
 
-from comicapi.issuestring import IssueString
-from comictaggerlib.coverimagewidget import CoverImageWidget
-from comictaggerlib.ui import ui_path
-from comictaggerlib.ui.qtutils import reduce_widget_font_size
-from comictalker.comictalker import ComicTalker, TalkerError
-from comictalker.resulttypes import ComicIssue
+from comictaggerlib.ui.qtutils import reduceWidgetFontSize
 
-logger = logging.getLogger(__name__)
+from .comicvinetalker import ComicVineTalker, ComicVineTalkerException
+from .coverimagewidget import CoverImageWidget
+from .issuestring import IssueString
+from .settings import ComicTaggerSettings
 
 
 class IssueNumberTableWidgetItem(QtWidgets.QTableWidgetItem):
-    def __lt__(self, other: object) -> bool:
-        assert isinstance(other, QtWidgets.QTableWidgetItem)
-        self_str: str = self.data(QtCore.Qt.ItemDataRole.DisplayRole)
-        other_str: str = other.data(QtCore.Qt.ItemDataRole.DisplayRole)
-        return (IssueString(self_str).as_float() or 0) < (IssueString(other_str).as_float() or 0)
+    def __lt__(self, other):
+        selfStr = self.data(QtCore.Qt.DisplayRole)
+        otherStr = other.data(QtCore.Qt.DisplayRole)
+        return IssueString(selfStr).asFloat() < IssueString(otherStr).asFloat()
 
 
 class IssueSelectionWindow(QtWidgets.QDialog):
-    def __init__(
-        self,
-        parent: QtWidgets.QWidget,
-        config: settngs.Namespace,
-        talker: ComicTalker,
-        series_id: str,
-        issue_number: str,
-    ) -> None:
-        super().__init__(parent)
 
-        uic.loadUi(ui_path / "issueselectionwindow.ui", self)
+    volume_id = 0
 
-        self.coverWidget = CoverImageWidget(
-            self.coverImageContainer, CoverImageWidget.AltCoverMode, config.runtime_config.user_cache_dir, talker
-        )
+    def __init__(self, parent, settings, series_id, issue_number):
+        super(IssueSelectionWindow, self).__init__(parent)
+
+        uic.loadUi(ComicTaggerSettings.getUIFile("issueselectionwindow.ui"), self)
+
+        self.coverWidget = CoverImageWidget(self.coverImageContainer, CoverImageWidget.AltCoverMode)
         gridlayout = QtWidgets.QGridLayout(self.coverImageContainer)
         gridlayout.addWidget(self.coverWidget)
         gridlayout.setContentsMargins(0, 0, 0, 0)
 
-        reduce_widget_font_size(self.twList)
-        reduce_widget_font_size(self.teDescription, 1)
+        reduceWidgetFontSize(self.twList)
+        reduceWidgetFontSize(self.teDescription, 1)
 
-        self.setWindowFlags(
-            QtCore.Qt.WindowType(
-                self.windowFlags()
-                | QtCore.Qt.WindowType.WindowSystemMenuHint
-                | QtCore.Qt.WindowType.WindowMaximizeButtonHint
-            )
-        )
+        self.setWindowFlags(self.windowFlags() | QtCore.Qt.WindowSystemMenuHint | QtCore.Qt.WindowMaximizeButtonHint)
 
         self.series_id = series_id
-        self.issue_id: str = ""
-        self.config = config
-        self.talker = talker
+        self.settings = settings
         self.url_fetch_thread = None
-        self.issue_list: list[ComicIssue] = []
-
-        # Display talker logo and set url
-        self.lblIssuesSourceName.setText(talker.attribution)
-
-        self.imageIssuesSourceWidget = CoverImageWidget(
-            self.imageIssuesSourceLogo,
-            CoverImageWidget.URLMode,
-            config.runtime_config.user_cache_dir,
-            talker,
-            False,
-        )
-        self.imageIssuesSourceWidget.showControls = False
-        gridlayoutIssuesSourceLogo = QtWidgets.QGridLayout(self.imageIssuesSourceLogo)
-        gridlayoutIssuesSourceLogo.addWidget(self.imageIssuesSourceWidget)
-        gridlayoutIssuesSourceLogo.setContentsMargins(0, 2, 0, 0)
-        self.imageIssuesSourceWidget.set_url(talker.logo_url)
 
         if issue_number is None or issue_number == "":
-            self.issue_number = "1"
+            self.issue_number = 1
         else:
             self.issue_number = issue_number
 
-        self.initial_id: str = ""
-        self.perform_query()
+        self.initial_id = None
+        self.performQuery()
 
         self.twList.resizeColumnsToContents()
-        self.twList.currentItemChanged.connect(self.current_item_changed)
-        self.twList.cellDoubleClicked.connect(self.cell_double_clicked)
+        self.twList.currentItemChanged.connect(self.currentItemChanged)
+        self.twList.cellDoubleClicked.connect(self.cellDoubleClicked)
 
         # now that the list has been sorted, find the initial record, and
         # select it
@@ -110,22 +73,29 @@ class IssueSelectionWindow(QtWidgets.QDialog):
             self.twList.selectRow(0)
         else:
             for r in range(0, self.twList.rowCount()):
-                issue_id = self.twList.item(r, 0).data(QtCore.Qt.ItemDataRole.UserRole)
+                issue_id = self.twList.item(r, 0).data(QtCore.Qt.UserRole)
                 if issue_id == self.initial_id:
                     self.twList.selectRow(r)
                     break
 
-    def perform_query(self) -> None:
-        QtWidgets.QApplication.setOverrideCursor(QtGui.QCursor(QtCore.Qt.CursorShape.WaitCursor))
+    def performQuery(self):
+
+        QtWidgets.QApplication.setOverrideCursor(QtGui.QCursor(QtCore.Qt.WaitCursor))
 
         try:
-            self.issue_list = self.talker.fetch_issues_by_series(self.series_id)
-        except TalkerError as e:
+            comicVine = ComicVineTalker()
+            volume_data = comicVine.fetchVolumeData(self.series_id)
+            self.issue_list = comicVine.fetchIssuesByVolume(self.series_id)
+        except ComicVineTalkerException as e:
             QtWidgets.QApplication.restoreOverrideCursor()
-            QtWidgets.QMessageBox.critical(self, f"{e.source} {e.code_name} Error", f"{e}")
+            if e.code == ComicVineTalkerException.RateLimit:
+                QtWidgets.QMessageBox.critical(self, self.tr("Comic Vine Error"), ComicVineTalker.getRateLimitMessage())
+            else:
+                QtWidgets.QMessageBox.critical(self, self.tr("Network Issue"), self.tr("Could not connect to Comic Vine to list issues!"))
             return
 
-        self.twList.setRowCount(0)
+        while self.twList.rowCount() > 0:
+            self.twList.removeRow(0)
 
         self.twList.setSortingEnabled(False)
 
@@ -133,15 +103,15 @@ class IssueSelectionWindow(QtWidgets.QDialog):
         for record in self.issue_list:
             self.twList.insertRow(row)
 
-            item_text = record.issue_number
+            item_text = record["issue_number"]
             item = IssueNumberTableWidgetItem(item_text)
-            item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
-            item.setData(QtCore.Qt.ItemDataRole.UserRole, record.id)
-            item.setData(QtCore.Qt.ItemDataRole.DisplayRole, item_text)
-            item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
+            item.setData(QtCore.Qt.ToolTipRole, item_text)
+            item.setData(QtCore.Qt.UserRole, record["id"])
+            item.setData(QtCore.Qt.DisplayRole, item_text)
+            item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
             self.twList.setItem(row, 0, item)
 
-            item_text = record.cover_date
+            item_text = record["cover_date"]
             if item_text is None:
                 item_text = ""
             # remove the day of "YYYY-MM-DD"
@@ -149,51 +119,49 @@ class IssueSelectionWindow(QtWidgets.QDialog):
             if len(parts) > 1:
                 item_text = parts[0] + "-" + parts[1]
 
-            qtw_item = QtWidgets.QTableWidgetItem(item_text)
-            qtw_item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
-            qtw_item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
-            self.twList.setItem(row, 1, qtw_item)
+            item = QtWidgets.QTableWidgetItem(item_text)
+            item.setData(QtCore.Qt.ToolTipRole, item_text)
+            item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
+            self.twList.setItem(row, 1, item)
 
-            item_text = record.name
+            item_text = record["name"]
             if item_text is None:
                 item_text = ""
-            qtw_item = QtWidgets.QTableWidgetItem(item_text)
-            qtw_item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
-            qtw_item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
-            self.twList.setItem(row, 2, qtw_item)
+            item = QtWidgets.QTableWidgetItem(item_text)
+            item.setData(QtCore.Qt.ToolTipRole, item_text)
+            item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
+            self.twList.setItem(row, 2, item)
 
-            if (
-                IssueString(record.issue_number).as_string().casefold()
-                == IssueString(self.issue_number).as_string().casefold()
-            ):
-                self.initial_id = record.id
+            if IssueString(record["issue_number"]).asString().lower() == IssueString(self.issue_number).asString().lower():
+                self.initial_id = record["id"]
 
             row += 1
 
         self.twList.setSortingEnabled(True)
-        self.twList.sortItems(0, QtCore.Qt.SortOrder.AscendingOrder)
+        self.twList.sortItems(0, QtCore.Qt.AscendingOrder)
 
         QtWidgets.QApplication.restoreOverrideCursor()
 
-    def cell_double_clicked(self, r: int, c: int) -> None:
+    def cellDoubleClicked(self, r, c):
         self.accept()
 
-    def current_item_changed(self, curr: QtCore.QModelIndex | None, prev: QtCore.QModelIndex | None) -> None:
+    def currentItemChanged(self, curr, prev):
+
         if curr is None:
             return
         if prev is not None and prev.row() == curr.row():
             return
 
-        self.issue_id = self.twList.item(curr.row(), 0).data(QtCore.Qt.ItemDataRole.UserRole)
+        self.issue_id = self.twList.item(curr.row(), 0).data(QtCore.Qt.UserRole)
 
         # list selection was changed, update the the issue cover
         for record in self.issue_list:
-            if record.id == self.issue_id:
-                self.issue_number = record.issue_number
-                self.coverWidget.set_issue_details(self.issue_id, [record.image_url, *record.alt_image_urls])
-                if record.description is None:
+            if record["id"] == self.issue_id:
+                self.issue_number = record["issue_number"]
+                self.coverWidget.setIssueID(int(self.issue_id))
+                if record["description"] is None:
                     self.teDescription.setText("")
                 else:
-                    self.teDescription.setText(record.description)
+                    self.teDescription.setText(record["description"])
 
                 break

comictaggerlib/issuestring.py

@@ -0,0 +1 @@
+from comicapi.issuestring import *

comictaggerlib/log.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-import logging.handlers
-import pathlib
-import platform
-import sys
-
-from comictaggerlib.ctversion import version
-
-logger = logging.getLogger("comictagger")
-
-
-def get_filename(filename: str) -> str:
-    filename, _, number = filename.rpartition(".")
-    return filename.removesuffix("log") + number + ".log"
-
-
-def get_file_handler(filename: pathlib.Path) -> logging.FileHandler:
-    file_handler = logging.handlers.RotatingFileHandler(filename, encoding="utf-8", backupCount=10)
-    file_handler.namer = get_filename
-
-    if filename.is_file() and filename.stat().st_size > 0:
-        file_handler.doRollover()
-    return file_handler
-
-
-def setup_logging(verbose: int, log_dir: pathlib.Path) -> None:
-    logging.getLogger("comicapi").setLevel(logging.DEBUG)
-    logging.getLogger("comictaggerlib").setLevel(logging.DEBUG)
-    logging.getLogger("comictalker").setLevel(logging.DEBUG)
-
-    log_file = log_dir / "ComicTagger.log"
-    log_dir.mkdir(parents=True, exist_ok=True)
-
-    stream_handler = logging.StreamHandler()
-    file_handler = get_file_handler(log_file)
-
-    if verbose > 1:
-        stream_handler.setLevel(logging.DEBUG)
-    elif verbose > 0:
-        stream_handler.setLevel(logging.INFO)
-    else:
-        stream_handler.setLevel(logging.WARNING)
-
-    logging.basicConfig(
-        handlers=[stream_handler, file_handler],
-        level=logging.WARNING,
-        format="%(asctime)s | %(name)s | %(levelname)s | %(message)s",
-        datefmt="%Y-%m-%dT%H:%M:%S",
-    )
-
-    logger.info(
-        "ComicTagger Version: %s running on: %s PyInstaller: %s",
-        version,
-        platform.system(),
-        "Yes" if getattr(sys, "frozen", None) else "No",
-    )

comictaggerlib/logwindow.py

@@ -1,51 +1,35 @@
 """A PyQT4 dialog to a text file or log"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import logging
+from PyQt5 import QtCore, QtGui, QtWidgets, uic
 
-from PyQt5 import QtCore, QtWidgets, uic
-
-from comictaggerlib.ui import qtutils, ui_path
-
-logger = logging.getLogger(__name__)
+from .settings import ComicTaggerSettings
 
 
 class LogWindow(QtWidgets.QDialog):
-    def __init__(self, parent: QtWidgets.QWidget) -> None:
-        super().__init__(parent)
+    def __init__(self, parent):
+        super(LogWindow, self).__init__(parent)
 
-        uic.loadUi(ui_path / "logwindow.ui", self)
+        uic.loadUi(ComicTaggerSettings.getUIFile("logwindow.ui"), self)
 
-        self.setWindowFlags(
-            QtCore.Qt.WindowType(
-                self.windowFlags()
-                | QtCore.Qt.WindowType.WindowSystemMenuHint
-                | QtCore.Qt.WindowType.WindowMaximizeButtonHint
-            )
-        )
+        self.setWindowFlags(self.windowFlags() | QtCore.Qt.WindowSystemMenuHint | QtCore.Qt.WindowMaximizeButtonHint)
 
-    def set_text(self, text: str | bytes | None) -> None:
+    def setText(self, text):
         try:
-            if text is not None:
-                if isinstance(text, bytes):
-                    text = text.decode("utf-8")
-                self.textEdit.setPlainText(text)
-        except AttributeError:
+            text = text.decode()
+        except:
             pass
-        except Exception as e:
-            logger.exception("Displaying raw tags failed")
-            qtutils.qt_error("Displaying raw tags failed:", e)
+        self.textEdit.setPlainText(text)

comictaggerlib/main.py

@@ -1,226 +1,103 @@
 """A python app to (automatically) tag comic archives"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import argparse
-import json
-import locale
-import logging
-import logging.handlers
 import os
+import platform
 import signal
-import subprocess
 import sys
+import traceback
 
-import settngs
+from . import cli, utils
+from .comicvinetalker import ComicVineTalker
+from .options import Options
+from .settings import ComicTaggerSettings
 
-import comicapi
-import comictalker
-from comictaggerlib import cli, ctsettings
-from comictaggerlib.ctversion import version
-from comictaggerlib.log import setup_logging
-
-if sys.version_info < (3, 10):
-    import importlib_metadata
-else:
-    import importlib.metadata as importlib_metadata
-
-logger = logging.getLogger("comictagger")
+# Need to load setting before anything else
+SETTINGS = ComicTaggerSettings()
 
 try:
-    from comictaggerlib import gui
+    qt_available = True
+    from PyQt5 import QtCore, QtGui, QtWidgets
 
-    qt_available = gui.qt_available
-except Exception:
-    logger.exception("Qt unavailable")
+    from .taggerwindow import TaggerWindow
+except ImportError as e:
     qt_available = False
 
 
-logger.setLevel(logging.DEBUG)
+def ctmain():
+    opts = Options()
+    opts.parseCmdLineArgs()
 
+    # manage the CV API key
+    if opts.cv_api_key:
+        if opts.cv_api_key != SETTINGS.cv_api_key:
+            SETTINGS.cv_api_key = opts.cv_api_key
+            SETTINGS.save()
+    if opts.only_set_key:
+        print("Key set")
+        return
 
-def _lang_code_mac() -> str:
-    """
-    stolen from https://github.com/mu-editor/mu
-    Returns the user's language preference as defined in the Language & Region
-    preference pane in macOS's System Preferences.
-    """
+    ComicVineTalker.api_key = SETTINGS.cv_api_key
 
-    # Uses the shell command `defaults read -g AppleLocale` that prints out a
-    # language code to standard output. Assumptions about the command:
-    # - It exists and is in the shell's PATH.
-    # - It accepts those arguments.
-    # - It returns a usable language code.
-    #
-    # Reference documentation:
-    # - The man page for the `defaults` command on macOS.
-    # - The macOS underlying API:
-    #   https://developer.apple.com/documentation/foundation/nsuserdefaults.
+    signal.signal(signal.SIGINT, signal.SIG_DFL)
 
-    lang_detect_command = "defaults read -g AppleLocale"
+    if not qt_available and not opts.no_gui:
+        opts.no_gui = True
+        print("PyQt5 is not available.  ComicTagger is limited to command-line mode.", file=sys.stderr)
 
-    status, output = subprocess.getstatusoutput(lang_detect_command)
-    if status == 0:
-        # Command was successful.
-        lang_code = output
+    if opts.no_gui:
+        cli.cli_mode(opts, SETTINGS)
     else:
-        logging.warning("Language detection command failed: %r", output)
-        lang_code = ""
 
-    return lang_code
+        os.environ["QT_AUTO_SCREEN_SCALE_FACTOR"] = "1"
 
+        # if platform.system() == "Darwin":
+        #    QtWidgets.QApplication.setStyle("macintosh")
+        # else:
+        #    QtWidgets.QApplication.setStyle("Fusion")
 
-def configure_locale() -> None:
-    if sys.platform == "darwin" and "LANG" not in os.environ:
-        code = _lang_code_mac()
-        if code != "":
-            os.environ["LANG"] = f"{code}.utf-8"
+        app = QtWidgets.QApplication(sys.argv)
+        if platform.system() == "Darwin":
+            # Set the MacOS dock icon
+            app.setWindowIcon(QtGui.QIcon(ComicTaggerSettings.getGraphic("app.png")))
 
-    locale.setlocale(locale.LC_ALL, "")
-    sys.stdout.reconfigure(encoding=sys.getdefaultencoding())  # type: ignore[attr-defined]
-    sys.stderr.reconfigure(encoding=sys.getdefaultencoding())  # type: ignore[attr-defined]
-    sys.stdin.reconfigure(encoding=sys.getdefaultencoding())  # type: ignore[attr-defined]
+        if platform.system() == "Windows":
+            # For pure python, tell windows that we're not python,
+            # so we can have our own taskbar icon
+            import ctypes
 
+            myappid = u"comictagger"  # arbitrary string
+            ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
+
+        if platform.system() != "Linux":
+            img = QtGui.QPixmap(ComicTaggerSettings.getGraphic("tags.png"))
+
+            splash = QtWidgets.QSplashScreen(img)
+            splash.show()
+            splash.raise_()
+            app.processEvents()
 
-def update_publishers(config: settngs.Config[settngs.Namespace]) -> None:
-    json_file = config[0].runtime_config.user_config_dir / "publishers.json"
-    if json_file.exists():
         try:
-            comicapi.utils.update_publishers(json.loads(json_file.read_text("utf-8")))
+            tagger_window = TaggerWindow(opts.file_list, SETTINGS, opts=opts)
+            tagger_window.setWindowIcon(QtGui.QIcon(ComicTaggerSettings.getGraphic("app.png")))
+            tagger_window.show()
+
+            if platform.system() != "Linux":
+                splash.finish(tagger_window)
+
+            sys.exit(app.exec_())
         except Exception as e:
-            logger.exception("Failed to load publishers from %s: %s", json_file, e)
-
-
-class App:
-    """docstring for App"""
-
-    def __init__(self) -> None:
-        self.config: settngs.Config[settngs.Namespace]
-        self.initial_arg_parser = ctsettings.initial_commandline_parser()
-        self.config_load_success = False
-
-    def run(self) -> None:
-        configure_locale()
-        conf = self.initialize()
-        self.initialize_dirs(conf.config)
-        self.load_plugins(conf)
-        self.register_settings()
-        self.config = self.parse_settings(conf.config)
-
-        self.main()
-
-    def load_plugins(self, opts: argparse.Namespace) -> None:
-        comicapi.comicarchive.load_archive_plugins()
-        ctsettings.talkers = comictalker.get_talkers(version, opts.config.user_cache_dir)
-
-    def initialize(self) -> argparse.Namespace:
-        conf, _ = self.initial_arg_parser.parse_known_args()
-        assert conf is not None
-        setup_logging(conf.verbose, conf.config.user_log_dir)
-        return conf
-
-    def register_settings(self) -> None:
-        self.manager = settngs.Manager(
-            """A utility for reading and writing metadata to comic archives.\n\n\nIf no options are given, %(prog)s will run in windowed mode.""",
-            "For more help visit the wiki at: https://github.com/comictagger/comictagger/wiki",
-        )
-        ctsettings.register_commandline_settings(self.manager)
-        ctsettings.register_file_settings(self.manager)
-        ctsettings.register_plugin_settings(self.manager)
-
-    def parse_settings(self, config_paths: ctsettings.ComicTaggerPaths) -> settngs.Config[settngs.Namespace]:
-        cfg, self.config_load_success = self.manager.parse_config(config_paths.user_config_dir / "settings.json")
-        config = self.manager.get_namespace(cfg)
-
-        config = ctsettings.validate_commandline_settings(config, self.manager)
-        config = ctsettings.validate_file_settings(config)
-        config = ctsettings.validate_plugin_settings(config)
-        return config
-
-    def initialize_dirs(self, paths: ctsettings.ComicTaggerPaths) -> None:
-        paths.user_data_dir.mkdir(parents=True, exist_ok=True)
-        paths.user_config_dir.mkdir(parents=True, exist_ok=True)
-        paths.user_cache_dir.mkdir(parents=True, exist_ok=True)
-        paths.user_state_dir.mkdir(parents=True, exist_ok=True)
-        paths.user_log_dir.mkdir(parents=True, exist_ok=True)
-        logger.debug("user_data_dir: %s", paths.user_data_dir)
-        logger.debug("user_config_dir: %s", paths.user_config_dir)
-        logger.debug("user_cache_dir: %s", paths.user_cache_dir)
-        logger.debug("user_state_dir: %s", paths.user_state_dir)
-        logger.debug("user_log_dir: %s", paths.user_log_dir)
-
-    def main(self) -> None:
-        assert self.config is not None
-        # config already loaded
-        error = None
-
-        talkers = ctsettings.talkers
-        del ctsettings.talkers
-
-        if len(talkers) < 1:
-            error = error = (
-                f"Failed to load any talkers, please re-install and check the log located in '{self.config[0].runtime_config.user_log_dir}' for more details",
-                True,
-            )
-
-        signal.signal(signal.SIGINT, signal.SIG_DFL)
-
-        logger.debug("Installed Packages")
-        for pkg in sorted(importlib_metadata.distributions(), key=lambda x: x.name):
-            logger.debug("%s\t%s", pkg.metadata["Name"], pkg.metadata["Version"])
-
-        comicapi.utils.load_publishers()
-        update_publishers(self.config)
-
-        if not qt_available and not self.config[0].runtime_no_gui:
-            self.config[0].runtime_no_gui = True
-            logger.warning("PyQt5 is not available. ComicTagger is limited to command-line mode.")
-
-        # manage the CV API key
-        # None comparison is used so that the empty string can unset the value
-        if not error and (
-            self.config[0].talker_comicvine_comicvine_key is not None
-            or self.config[0].talker_comicvine_comicvine_url is not None
-        ):
-            settings_path = self.config[0].runtime_config.user_config_dir / "settings.json"
-            if self.config_load_success:
-                self.manager.save_file(self.config[0], settings_path)
-
-        if self.config[0].commands_only_set_cv_key:
-            if self.config_load_success:
-                print("Key set")  # noqa: T201
-                return
-
-        if not self.config_load_success:
-            error = (
-                f"Failed to load settings, check the log located in '{self.config[0].runtime_config.user_log_dir}' for more details",
-                True,
-            )
-
-        if self.config[0].runtime_no_gui:
-            if error and error[1]:
-                print(f"A fatal error occurred please check the log for more information: {error[0]}")  # noqa: T201
-                raise SystemExit(1)
-            try:
-                cli.CLI(self.config[0], talkers).run()
-            except Exception:
-                logger.exception("CLI mode failed")
-        else:
-            gui.open_tagger_window(talkers, self.config, error)
-
-
-def main() -> None:
-    App().run()
+            QtWidgets.QMessageBox.critical(QtWidgets.QMainWindow(), "Error", "Unhandled exception in app:\n" + traceback.format_exc())

comictaggerlib/matchselectionwindow.py

@@ -1,91 +1,75 @@
 """A PyQT4 dialog to select from automated issue matches"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import logging
 import os
 
-import settngs
-from PyQt5 import QtCore, QtWidgets, uic
+from PyQt5 import QtCore, QtGui, QtWidgets, uic
 
-from comicapi.comicarchive import ComicArchive
-from comictaggerlib.coverimagewidget import CoverImageWidget
-from comictaggerlib.resulttypes import IssueResult
-from comictaggerlib.ui import ui_path
-from comictaggerlib.ui.qtutils import reduce_widget_font_size
-from comictalker.comictalker import ComicTalker
+from comictaggerlib.ui.qtutils import reduceWidgetFontSize
 
-logger = logging.getLogger(__name__)
+from .coverimagewidget import CoverImageWidget
+from .settings import ComicTaggerSettings
 
 
 class MatchSelectionWindow(QtWidgets.QDialog):
-    def __init__(
-        self,
-        parent: QtWidgets.QWidget,
-        matches: list[IssueResult],
-        comic_archive: ComicArchive,
-        config: settngs.Namespace,
-        talker: ComicTalker,
-    ) -> None:
-        super().__init__(parent)
 
-        uic.loadUi(ui_path / "matchselectionwindow.ui", self)
+    volume_id = 0
 
-        self.altCoverWidget = CoverImageWidget(
-            self.altCoverContainer, CoverImageWidget.AltCoverMode, config.runtime_config.user_cache_dir, talker
-        )
+    def __init__(self, parent, matches, comic_archive):
+        super(MatchSelectionWindow, self).__init__(parent)
+
+        uic.loadUi(ComicTaggerSettings.getUIFile("matchselectionwindow.ui"), self)
+
+        self.altCoverWidget = CoverImageWidget(self.altCoverContainer, CoverImageWidget.AltCoverMode)
         gridlayout = QtWidgets.QGridLayout(self.altCoverContainer)
         gridlayout.addWidget(self.altCoverWidget)
         gridlayout.setContentsMargins(0, 0, 0, 0)
 
-        self.archiveCoverWidget = CoverImageWidget(self.archiveCoverContainer, CoverImageWidget.ArchiveMode, None, None)
+        self.archiveCoverWidget = CoverImageWidget(self.archiveCoverContainer, CoverImageWidget.ArchiveMode)
         gridlayout = QtWidgets.QGridLayout(self.archiveCoverContainer)
         gridlayout.addWidget(self.archiveCoverWidget)
         gridlayout.setContentsMargins(0, 0, 0, 0)
 
-        reduce_widget_font_size(self.twList)
-        reduce_widget_font_size(self.teDescription, 1)
+        reduceWidgetFontSize(self.twList)
+        reduceWidgetFontSize(self.teDescription, 1)
 
-        self.setWindowFlags(
-            QtCore.Qt.WindowType(
-                self.windowFlags()
-                | QtCore.Qt.WindowType.WindowSystemMenuHint
-                | QtCore.Qt.WindowType.WindowMaximizeButtonHint
-            )
-        )
+        self.setWindowFlags(self.windowFlags() | QtCore.Qt.WindowSystemMenuHint | QtCore.Qt.WindowMaximizeButtonHint)
 
-        self.matches: list[IssueResult] = matches
+        self.matches = matches
         self.comic_archive = comic_archive
 
-        self.twList.currentItemChanged.connect(self.current_item_changed)
-        self.twList.cellDoubleClicked.connect(self.cell_double_clicked)
+        self.twList.currentItemChanged.connect(self.currentItemChanged)
+        self.twList.cellDoubleClicked.connect(self.cellDoubleClicked)
 
-        self.update_data()
+        self.updateData()
 
-    def update_data(self) -> None:
-        self.set_cover_image()
-        self.populate_table()
+    def updateData(self):
+
+        self.setCoverImage()
+        self.populateTable()
         self.twList.resizeColumnsToContents()
         self.twList.selectRow(0)
 
         path = self.comic_archive.path
-        self.setWindowTitle(f"Select correct match: {os.path.split(path)[1]}")
+        self.setWindowTitle("Select correct match: {0}".format(os.path.split(path)[1]))
 
-    def populate_table(self) -> None:
-        self.twList.setRowCount(0)
+    def populateTable(self):
+
+        while self.twList.rowCount() > 0:
+            self.twList.removeRow(0)
 
         self.twList.setSortingEnabled(False)
 
@@ -95,72 +79,70 @@ class MatchSelectionWindow(QtWidgets.QDialog):
 
             item_text = match["series"]
             item = QtWidgets.QTableWidgetItem(item_text)
-            item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
-            item.setData(QtCore.Qt.ItemDataRole.UserRole, (match,))
-            item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
+            item.setData(QtCore.Qt.ToolTipRole, item_text)
+            item.setData(QtCore.Qt.UserRole, (match,))
+            item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
             self.twList.setItem(row, 0, item)
 
             if match["publisher"] is not None:
-                item_text = str(match["publisher"])
+                item_text = "{0}".format(match["publisher"])
             else:
                 item_text = "Unknown"
             item = QtWidgets.QTableWidgetItem(item_text)
-            item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
-            item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
+            item.setData(QtCore.Qt.ToolTipRole, item_text)
+            item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
             self.twList.setItem(row, 1, item)
 
             month_str = ""
             year_str = "????"
             if match["month"] is not None:
-                month_str = f"-{int(match['month']):02d}"
+                month_str = "-{0:02d}".format(int(match["month"]))
             if match["year"] is not None:
-                year_str = str(match["year"])
+                year_str = "{0}".format(match["year"])
 
             item_text = year_str + month_str
             item = QtWidgets.QTableWidgetItem(item_text)
-            item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
-            item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
+            item.setData(QtCore.Qt.ToolTipRole, item_text)
+            item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
             self.twList.setItem(row, 2, item)
 
             item_text = match["issue_title"]
             if item_text is None:
                 item_text = ""
             item = QtWidgets.QTableWidgetItem(item_text)
-            item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
-            item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
+            item.setData(QtCore.Qt.ToolTipRole, item_text)
+            item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
             self.twList.setItem(row, 3, item)
 
             row += 1
 
         self.twList.resizeColumnsToContents()
         self.twList.setSortingEnabled(True)
-        self.twList.sortItems(2, QtCore.Qt.SortOrder.AscendingOrder)
+        self.twList.sortItems(2, QtCore.Qt.AscendingOrder)
         self.twList.selectRow(0)
         self.twList.resizeColumnsToContents()
         self.twList.horizontalHeader().setStretchLastSection(True)
 
-    def cell_double_clicked(self, r: int, c: int) -> None:
+    def cellDoubleClicked(self, r, c):
         self.accept()
 
-    def current_item_changed(self, curr: QtCore.QModelIndex, prev: QtCore.QModelIndex) -> None:
+    def currentItemChanged(self, curr, prev):
+
         if curr is None:
             return
         if prev is not None and prev.row() == curr.row():
             return
 
-        self.altCoverWidget.set_issue_details(
-            self.current_match()["issue_id"],
-            [self.current_match()["image_url"], *self.current_match()["alt_image_urls"]],
-        )
-        if self.current_match()["description"] is None:
+        self.altCoverWidget.setIssueID(self.currentMatch()["issue_id"])
+        if self.currentMatch()["description"] is None:
             self.teDescription.setText("")
         else:
-            self.teDescription.setText(self.current_match()["description"])
+            self.teDescription.setText(self.currentMatch()["description"])
 
-    def set_cover_image(self) -> None:
-        self.archiveCoverWidget.set_archive(self.comic_archive)
+    def setCoverImage(self):
+        self.archiveCoverWidget.setArchive(self.comic_archive)
 
-    def current_match(self) -> IssueResult:
+    def currentMatch(self):
         row = self.twList.currentRow()
-        match: IssueResult = self.twList.item(row, 0).data(QtCore.Qt.ItemDataRole.UserRole)[0]
+        match = self.twList.item(row, 0).data(QtCore.Qt.UserRole)[0]
         return match

comictaggerlib/optionalmsgdialog.py

@@ -6,114 +6,92 @@ checked = OptionalMessageDialog.msg(self, "Disclaimer",
                             "This is beta software, and you are using it at your own risk!",
                          )
 
-said_yes, checked = OptionalMessageDialog.question(self, "QtWidgets.Question",
+said_yes, checked = OptionalMessageDialog.question(self, "Question",
                             "Are you sure you wish to do this?",
                          )
 """
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import logging
-
-from PyQt5 import QtCore, QtWidgets
-
-logger = logging.getLogger(__name__)
+from PyQt5.QtCore import *
+from PyQt5.QtGui import *
+from PyQt5.QtWidgets import *
 
 StyleMessage = 0
 StyleQuestion = 1
 
 
-class OptionalMessageDialog(QtWidgets.QDialog):
-    def __init__(
-        self, parent: QtWidgets.QWidget, style: int, title: str, msg: str, checked: bool = False, check_text: str = ""
-    ) -> None:
-        super().__init__(parent)
+class OptionalMessageDialog(QDialog):
+    def __init__(self, parent, style, title, msg, check_state=Qt.Unchecked, check_text=None):
+        QDialog.__init__(self, parent)
 
         self.setWindowTitle(title)
         self.was_accepted = False
-        layout = QtWidgets.QVBoxLayout(self)
 
-        self.theLabel = QtWidgets.QLabel(msg)
+        l = QVBoxLayout(self)
+
+        self.theLabel = QLabel(msg)
         self.theLabel.setWordWrap(True)
-        self.theLabel.setTextFormat(QtCore.Qt.TextFormat.RichText)
+        self.theLabel.setTextFormat(Qt.RichText)
         self.theLabel.setOpenExternalLinks(True)
-        self.theLabel.setTextInteractionFlags(
-            QtCore.Qt.TextInteractionFlag.TextSelectableByMouse
-            | QtCore.Qt.TextInteractionFlag.LinksAccessibleByMouse
-            | QtCore.Qt.TextInteractionFlag.LinksAccessibleByKeyboard
-        )
+        self.theLabel.setTextInteractionFlags(Qt.TextSelectableByMouse | Qt.LinksAccessibleByMouse | Qt.LinksAccessibleByKeyboard)
 
-        layout.addWidget(self.theLabel)
-        layout.insertSpacing(-1, 10)
+        l.addWidget(self.theLabel)
+        l.insertSpacing(-1, 10)
 
-        if not check_text:
+        if check_text is None:
             if style == StyleQuestion:
                 check_text = "Remember this answer"
             else:
                 check_text = "Don't show this message again"
 
-        self.theCheckBox = QtWidgets.QCheckBox(check_text)
+        self.theCheckBox = QCheckBox(check_text)
 
-        self.theCheckBox.setChecked(checked)
+        self.theCheckBox.setCheckState(check_state)
 
-        layout.addWidget(self.theCheckBox)
+        l.addWidget(self.theCheckBox)
 
-        btnbox_style: QtWidgets.QDialogButtonBox.StandardButtons | QtWidgets.QDialogButtonBox.StandardButton
+        btnbox_style = QDialogButtonBox.Ok
         if style == StyleQuestion:
-            btnbox_style = QtWidgets.QDialogButtonBox.StandardButton.Yes | QtWidgets.QDialogButtonBox.StandardButton.No
-        else:
-            btnbox_style = QtWidgets.QDialogButtonBox.StandardButton.Ok
+            btnbox_style = QDialogButtonBox.Yes | QDialogButtonBox.No
 
-        self.theButtonBox = QtWidgets.QDialogButtonBox(btnbox_style, parent=self)
-        self.theButtonBox.accepted.connect(self.accept)
-        self.theButtonBox.rejected.connect(self.reject)
+        self.theButtonBox = QDialogButtonBox(btnbox_style, parent=self, accepted=self.accept, rejected=self.reject)
 
-        layout.addWidget(self.theButtonBox)
+        l.addWidget(self.theButtonBox)
 
-    def accept(self) -> None:
+    def accept(self):
         self.was_accepted = True
-        QtWidgets.QDialog.accept(self)
+        QDialog.accept(self)
 
-    def reject(self) -> None:
+    def reject(self):
         self.was_accepted = False
-        QtWidgets.QDialog.reject(self)
+        QDialog.reject(self)
 
     @staticmethod
-    def msg(parent: QtWidgets.QWidget, title: str, msg: str, checked: bool = False, check_text: str = "") -> bool:
-        d = OptionalMessageDialog(parent, StyleMessage, title, msg, checked=checked, check_text=check_text)
+    def msg(parent, title, msg, check_state=Qt.Unchecked, check_text=None):
 
-        d.exec()
+        d = OptionalMessageDialog(parent, StyleMessage, title, msg, check_state=check_state, check_text=check_text)
+
+        d.exec_()
         return d.theCheckBox.isChecked()
 
     @staticmethod
-    def question(
-        parent: QtWidgets.QWidget, title: str, msg: str, checked: bool = False, check_text: str = ""
-    ) -> tuple[bool, bool]:
-        d = OptionalMessageDialog(parent, StyleQuestion, title, msg, checked=checked, check_text=check_text)
+    def question(parent, title, msg, check_state=Qt.Unchecked, check_text=None):
 
-        d.exec()
+        d = OptionalMessageDialog(parent, StyleQuestion, title, msg, check_state=check_state, check_text=check_text)
+
+        d.exec_()
 
         return d.was_accepted, d.theCheckBox.isChecked()
-
-    @staticmethod
-    def msg_no_checkbox(
-        parent: QtWidgets.QWidget, title: str, msg: str, checked: bool = False, check_text: str = ""
-    ) -> bool:
-        d = OptionalMessageDialog(parent, StyleMessage, title, msg, checked=checked, check_text=check_text)
-        d.theCheckBox.hide()
-
-        d.exec()
-        return d.theCheckBox.isChecked()

comictaggerlib/options.py

@@ -0,0 +1,437 @@
+"""CLI options class for ComicTagger app"""
+
+# Copyright 2012-2014 Anthony Beville
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import getopt
+import os
+import platform
+import sys
+import traceback
+
+from . import _version, utils
+from .comicarchive import MetaDataStyle
+from .genericmetadata import GenericMetadata
+from .versionchecker import VersionChecker
+
+try:
+    import argparse
+except ImportError:
+    pass
+
+
+class Options:
+    help_text = """Usage: {0} [option] ... [file [files ...]]
+
+A utility for reading and writing metadata to comic archives.
+
+If no options are given, {0} will run in windowed mode.
+
+-p, --print                 Print out tag info from file. Specify type
+                            (via -t) to get only info of that tag type.
+    --raw                   With -p, will print out the raw tag block(s)
+                            from the file.
+-d, --delete                Deletes the tag block of specified type (via
+                            -t).
+-c, --copy=SOURCE           Copy the specified source tag block to
+                            destination style specified via -t
+                            (potentially lossy operation).
+-s, --save                  Save out tags as specified type (via -t).
+                            Must specify also at least -o, -p, or -m.
+    --nooverwrite           Don't modify tag block if it already exists
+                            (relevant for -s or -c).
+-1, --assume-issue-one      Assume issue number is 1 if not found
+                            (relevant for -s).
+-n, --dryrun                Don't actually modify file (only relevant for
+                            -d, -s, or -r).
+-t, --type=TYPE             Specify TYPE as either "CR", "CBL", or
+                            "COMET" (as either ComicRack, ComicBookLover,
+                            or CoMet style tags, respectively).
+-f, --parsefilename         Parse the filename to get some info,
+                            specifically series name, issue number,
+                            volume, and publication year.
+-i, --interactive           Interactively query the user when there are
+                            multiple matches for an online search.
+    --nosummary             Suppress the default summary after a save
+                            operation.
+-o, --online                Search online and attempt to identify file
+                            using existing metadata and images in archive.
+                            May be used in conjunction with -f and -m.
+    --id=ID                 Use the issue ID when searching online.
+                            Overrides all other metadata.
+-m, --metadata=LIST         Explicitly define, as a list, some tags to be
+                            used.  e.g.:
+                            "series=Plastic Man, publisher=Quality Comics"
+                            "series=Kickers^, Inc., issue=1, year=1986"
+                            Name-Value pairs are comma separated. Use a
+                            "^" to escape an "=" or a ",", as shown in
+                            the example above.  Some names that can be
+                            used: series, issue, issueCount, year,
+                            publisher, title
+-r, --rename                Rename the file based on specified tag style.
+    --noabort               Don't abort save operation when online match
+                            is of low confidence.
+-e, --export-to-zip         Export RAR archive to Zip format.
+    --delete-rar            Delete original RAR archive after successful
+                            export to Zip.
+    --abort-on-conflict     Don't export to zip if intended new filename
+                            exists (otherwise, creates a new unique
+                            filename).
+-S, --script=FILE           Run an "add-on" python script that uses the
+                            ComicTagger library for custom processing.
+                            Script arguments can follow the script name.
+-R, --recursive             Recursively include files in sub-folders.
+    --cv-api-key=KEY        Use the given Comic Vine API Key (persisted
+                            in settings).
+    --only-set-cv-key       Only set the Comic Vine API key and quit.
+-w, --wait-on-cv-rate-limit When encountering a Comic Vine rate limit
+                            error, wait and retry query.
+-v, --verbose               Be noisy when doing what it does.
+    --terse                 Don't say much (for print mode).
+    --version               Display version.
+-h, --help                  Display this message.
+
+For more help visit the wiki at: http://code.google.com/p/comictagger/
+    """
+
+    def __init__(self):
+        self.data_style = None
+        self.no_gui = False
+        self.filename = None
+        self.verbose = False
+        self.terse = False
+        self.auto_imprint = False
+        self.metadata = None
+        self.print_tags = False
+        self.copy_tags = False
+        self.delete_tags = False
+        self.export_to_zip = False
+        self.abort_export_on_conflict = False
+        self.delete_rar_after_export = False
+        self.search_online = False
+        self.dryrun = False
+        self.abortOnLowConfidence = True
+        self.save_tags = False
+        self.parse_filename = False
+        self.show_save_summary = True
+        self.raw = False
+        self.cv_api_key = None
+        self.only_set_key = False
+        self.rename_file = False
+        self.no_overwrite = False
+        self.interactive = False
+        self.issue_id = None
+        self.recursive = False
+        self.run_script = False
+        self.script = None
+        self.wait_and_retry_on_rate_limit = False
+        self.assume_issue_is_one_if_not_set = False
+        self.file_list = []
+
+    def display_msg_and_quit(self, msg, code, show_help=False):
+        appname = os.path.basename(sys.argv[0])
+        if msg is not None:
+            print(msg)
+        if show_help:
+            print((self.help_text.format(appname)))
+        else:
+            print("For more help, run with '--help'")
+        sys.exit(code)
+
+    def parseMetadataFromString(self, mdstr):
+        """The metadata string is a comma separated list of name-value pairs
+        The names match the attributes of the internal metadata struct (for now)
+        The caret is the special "escape character", since it's not common in
+        natural language text
+
+        example = "series=Kickers^, Inc. ,issue=1, year=1986"
+        """
+
+        escaped_comma = "^,"
+        escaped_equals = "^="
+        replacement_token = "<_~_>"
+
+        md = GenericMetadata()
+
+        # First, replace escaped commas with with a unique token (to be changed
+        # back later)
+        mdstr = mdstr.replace(escaped_comma, replacement_token)
+        tmp_list = mdstr.split(",")
+        md_list = []
+        for item in tmp_list:
+            item = item.replace(replacement_token, ",")
+            md_list.append(item)
+
+        # Now build a nice dict from the list
+        md_dict = dict()
+        for item in md_list:
+            # Make sure to fix any escaped equal signs
+            i = item.replace(escaped_equals, replacement_token)
+            key, value = i.split("=")
+            value = value.replace(replacement_token, "=").strip()
+            key = key.strip()
+            if key.lower() == "credit":
+                cred_attribs = value.split(":")
+                role = cred_attribs[0]
+                person = cred_attribs[1] if len(cred_attribs) > 1 else ""
+                primary = cred_attribs[2] if len(cred_attribs) > 2 else None
+                md.addCredit(person.strip(), role.strip(), True if primary is not None else False)
+            else:
+                md_dict[key] = value
+
+        # Map the dict to the metadata object
+        for key in md_dict:
+            if not hasattr(md, key):
+                print("Warning: '{0}' is not a valid tag name".format(key))
+            else:
+                md.isEmpty = False
+                setattr(md, key, md_dict[key])
+        # print(md)
+        return md
+
+    def launch_script(self, scriptfile):
+        # we were given a script.  special case for the args:
+        # 1. ignore everything before the -S,
+        # 2. pass all the ones that follow (including script name) to the
+        # script
+        script_args = list()
+        for idx, arg in enumerate(sys.argv):
+            if arg in ["-S", "--script"]:
+                # found script!
+                script_args = sys.argv[idx + 1 :]
+                break
+        sys.argv = script_args
+        if not os.path.exists(scriptfile):
+            print("Can't find {0}".format(scriptfile))
+        else:
+            # I *think* this makes sense:
+            #  assume the base name of the file is the module name
+            #  add the folder of the given file to the python path
+            #  import module
+            dirname = os.path.dirname(scriptfile)
+            module_name = os.path.splitext(os.path.basename(scriptfile))[0]
+            sys.path = [dirname] + sys.path
+            try:
+                script = __import__(module_name)
+
+                # Determine if the entry point exists before trying to run it
+                if "main" in dir(script):
+                    script.main()
+                else:
+                    print('Can\'t find entry point "main()" in module "{0}"'.format(module_name))
+            except Exception as e:
+                print("Script raised an unhandled exception: ", e)
+                print((traceback.format_exc()))
+
+        sys.exit(0)
+
+    def parseCmdLineArgs(self):
+
+        if platform.system() == "Darwin" and hasattr(sys, "frozen") and sys.frozen == 1:
+            # remove the PSN ("process serial number") argument from OS/X
+            input_args = [a for a in sys.argv[1:] if "-psn_0_" not in a]
+        else:
+            input_args = sys.argv[1:]
+
+        # first check if we're launching a script:
+        for n in range(len(input_args)):
+            if input_args[n] in ["-S", "--script"] and n + 1 < len(input_args):
+                # insert a "--" which will cause getopt to ignore the remaining args
+                # so they will be passed to the script
+                input_args.insert(n + 2, "--")
+                break
+
+        # parse command line options
+        try:
+            opts, args = getopt.getopt(
+                input_args,
+                "hpdt:fm:vownsrc:ieRS:1",
+                [
+                    "help",
+                    "print",
+                    "delete",
+                    "type=",
+                    "copy=",
+                    "parsefilename",
+                    "metadata=",
+                    "verbose",
+                    "online",
+                    "dryrun",
+                    "save",
+                    "rename",
+                    "raw",
+                    "noabort",
+                    "terse",
+                    "nooverwrite",
+                    "interactive",
+                    "nosummary",
+                    "version",
+                    "id=",
+                    "recursive",
+                    "script=",
+                    "export-to-zip",
+                    "delete-rar",
+                    "abort-on-conflict",
+                    "assume-issue-one",
+                    "cv-api-key=",
+                    "only-set-cv-key",
+                    "wait-on-cv-rate-limit",
+                ],
+            )
+
+        except getopt.GetoptError as err:
+            self.display_msg_and_quit(str(err), 2)
+
+        # process options
+        for o, a in opts:
+            if o in ("-h", "--help"):
+                self.display_msg_and_quit(None, 0, show_help=True)
+            if o in ("-v", "--verbose"):
+                self.verbose = True
+            if o in ("-S", "--script"):
+                self.run_script = True
+                self.script = a
+            if o in ("-R", "--recursive"):
+                self.recursive = True
+            if o in ("-p", "--print"):
+                self.print_tags = True
+            if o in ("-d", "--delete"):
+                self.delete_tags = True
+            if o in ("-i", "--interactive"):
+                self.interactive = True
+            if o in ("-a", "--auto-imprint"):
+                self.auto_imprint = True
+            if o in ("-c", "--copy"):
+                self.copy_tags = True
+                if a.lower() == "cr":
+                    self.copy_source = MetaDataStyle.CIX
+                elif a.lower() == "cbl":
+                    self.copy_source = MetaDataStyle.CBI
+                elif a.lower() == "comet":
+                    self.copy_source = MetaDataStyle.COMET
+                else:
+                    self.display_msg_and_quit("Invalid copy tag source type", 1)
+            if o in ("-o", "--online"):
+                self.search_online = True
+            if o in ("-n", "--dryrun"):
+                self.dryrun = True
+            if o in ("-m", "--metadata"):
+                self.metadata = self.parseMetadataFromString(a)
+            if o in ("-s", "--save"):
+                self.save_tags = True
+            if o in ("-r", "--rename"):
+                self.rename_file = True
+            if o in ("-e", "--export_to_zip"):
+                self.export_to_zip = True
+            if o == "--delete-rar":
+                self.delete_rar_after_export = True
+            if o == "--abort-on-conflict":
+                self.abort_export_on_conflict = True
+            if o in ("-f", "--parsefilename"):
+                self.parse_filename = True
+            if o in ("-w", "--wait-on-cv-rate-limit"):
+                self.wait_and_retry_on_rate_limit = True
+            if o == "--id":
+                self.issue_id = a
+            if o == "--raw":
+                self.raw = True
+            if o == "--noabort":
+                self.abortOnLowConfidence = False
+            if o == "--terse":
+                self.terse = True
+            if o == "--nosummary":
+                self.show_save_summary = False
+            if o in ("-1", "--assume-issue-one"):
+                self.assume_issue_is_one_if_not_set = True
+            if o == "--nooverwrite":
+                self.no_overwrite = True
+            if o == "--cv-api-key":
+                self.cv_api_key = a
+            if o == "--only-set-cv-key":
+                self.only_set_key = True
+            if o == "--version":
+                print("ComicTagger {0}:  Copyright (c) 2012-2014 Anthony Beville".format(_version.version))
+                print("Distributed under Apache License 2.0 (http://www.apache.org/licenses/LICENSE-2.0)")
+                sys.exit(0)
+            if o in ("-t", "--type"):
+                if a.lower() == "cr":
+                    self.data_style = MetaDataStyle.CIX
+                elif a.lower() == "cbl":
+                    self.data_style = MetaDataStyle.CBI
+                elif a.lower() == "comet":
+                    self.data_style = MetaDataStyle.COMET
+                else:
+                    self.display_msg_and_quit("Invalid tag type", 1)
+
+        if self.print_tags or self.delete_tags or self.save_tags or self.copy_tags or self.rename_file or self.export_to_zip or self.only_set_key:
+            self.no_gui = True
+
+        count = 0
+        if self.run_script:
+            count += 1
+        if self.print_tags:
+            count += 1
+        if self.delete_tags:
+            count += 1
+        if self.save_tags:
+            count += 1
+        if self.copy_tags:
+            count += 1
+        if self.rename_file:
+            count += 1
+        if self.export_to_zip:
+            count += 1
+        if self.only_set_key:
+            count += 1
+
+        if count > 1:
+            self.display_msg_and_quit("Must choose only one action of print, delete, save, copy, rename, export, set key, or run script", 1)
+
+        if self.script is not None:
+            self.launch_script(self.script)
+
+        if len(args) > 0:
+            if platform.system() == "Windows":
+                # no globbing on windows shell, so do it for them
+                import glob
+
+                self.file_list = []
+                for item in args:
+                    self.file_list.extend(glob.glob(item))
+                if len(self.file_list) > 0:
+                    self.filename = self.file_list[0]
+            else:
+                self.filename = args[0]
+                self.file_list = args
+
+        if self.only_set_key and self.cv_api_key is None:
+            self.display_msg_and_quit("Key not given!", 1)
+
+        if (self.only_set_key == False) and self.no_gui and (self.filename is None):
+            self.display_msg_and_quit("Command requires at least one filename!", 1)
+
+        if self.delete_tags and self.data_style is None:
+            self.display_msg_and_quit("Please specify the type to delete with -t", 1)
+
+        if self.save_tags and self.data_style is None:
+            self.display_msg_and_quit("Please specify the type to save with -t", 1)
+
+        if self.copy_tags and self.data_style is None:
+            self.display_msg_and_quit("Please specify the type to copy to with -t", 1)
+
+        # if self.rename_file and self.data_style is None:
+        #    self.display_msg_and_quit("Please specify the type to use for renaming with -t", 1)
+
+        if self.recursive:
+            self.file_list = utils.get_recursive_filelist(self.file_list)

comictaggerlib/pagebrowser.py

@@ -1,114 +1,104 @@
 """A PyQT4 dialog to show pages of a comic archive"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import logging
 import platform
 
 from PyQt5 import QtCore, QtGui, QtWidgets, uic
 
-from comicapi.comicarchive import ComicArchive
-from comicapi.genericmetadata import GenericMetadata
-from comictaggerlib.coverimagewidget import CoverImageWidget
-from comictaggerlib.graphics import graphics_path
-from comictaggerlib.ui import ui_path
-
-logger = logging.getLogger(__name__)
+from .coverimagewidget import CoverImageWidget
+from .settings import ComicTaggerSettings
 
 
 class PageBrowserWindow(QtWidgets.QDialog):
-    def __init__(self, parent: QtWidgets.QWidget, metadata: GenericMetadata) -> None:
-        super().__init__(parent)
+    def __init__(self, parent, metadata):
+        super(PageBrowserWindow, self).__init__(parent)
 
-        uic.loadUi(ui_path / "pagebrowser.ui", self)
+        uic.loadUi(ComicTaggerSettings.getUIFile("pagebrowser.ui"), self)
 
-        self.pageWidget = CoverImageWidget(self.pageContainer, CoverImageWidget.ArchiveMode, None, None)
+        self.pageWidget = CoverImageWidget(self.pageContainer, CoverImageWidget.ArchiveMode)
         gridlayout = QtWidgets.QGridLayout(self.pageContainer)
         gridlayout.addWidget(self.pageWidget)
         gridlayout.setContentsMargins(0, 0, 0, 0)
         self.pageWidget.showControls = False
 
-        self.setWindowFlags(
-            QtCore.Qt.WindowType(
-                self.windowFlags()
-                | QtCore.Qt.WindowType.WindowSystemMenuHint
-                | QtCore.Qt.WindowType.WindowMaximizeButtonHint
-            )
-        )
+        self.setWindowFlags(self.windowFlags() | QtCore.Qt.WindowSystemMenuHint | QtCore.Qt.WindowMaximizeButtonHint)
 
-        self.comic_archive: ComicArchive | None = None
+        self.comic_archive = None
         self.page_count = 0
         self.current_page_num = 0
         self.metadata = metadata
 
-        self.buttonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Close).setDefault(True)
+        self.buttonBox.button(QtWidgets.QDialogButtonBox.Close).setDefault(True)
         if platform.system() == "Darwin":
             self.btnPrev.setText("<<")
             self.btnNext.setText(">>")
         else:
-            self.btnPrev.setIcon(QtGui.QIcon(str(graphics_path / "left.png")))
-            self.btnNext.setIcon(QtGui.QIcon(str(graphics_path / "right.png")))
+            self.btnPrev.setIcon(QtGui.QIcon(ComicTaggerSettings.getGraphic("left.png")))
+            self.btnNext.setIcon(QtGui.QIcon(ComicTaggerSettings.getGraphic("right.png")))
 
-        self.btnNext.clicked.connect(self.next_page)
-        self.btnPrev.clicked.connect(self.prev_page)
+        self.btnNext.clicked.connect(self.nextPage)
+        self.btnPrev.clicked.connect(self.prevPage)
         self.show()
 
         self.btnNext.setEnabled(False)
         self.btnPrev.setEnabled(False)
 
-    def reset(self) -> None:
+    def reset(self):
         self.comic_archive = None
         self.page_count = 0
         self.current_page_num = 0
-        self.metadata = GenericMetadata()
+        self.metadata = None
 
         self.btnNext.setEnabled(False)
         self.btnPrev.setEnabled(False)
         self.pageWidget.clear()
 
-    def set_comic_archive(self, ca: ComicArchive) -> None:
+    def setComicArchive(self, ca):
+
         self.comic_archive = ca
-        self.page_count = ca.get_number_of_pages()
+        self.page_count = ca.getNumberOfPages()
         self.current_page_num = 0
-        self.pageWidget.set_archive(self.comic_archive)
-        self.set_page()
+        self.pageWidget.setArchive(self.comic_archive)
+        self.setPage()
 
         if self.page_count > 1:
             self.btnNext.setEnabled(True)
             self.btnPrev.setEnabled(True)
 
-    def next_page(self) -> None:
+    def nextPage(self):
+
         if self.current_page_num + 1 < self.page_count:
             self.current_page_num += 1
         else:
             self.current_page_num = 0
-        self.set_page()
+        self.setPage()
+
+    def prevPage(self):
 
-    def prev_page(self) -> None:
         if self.current_page_num - 1 >= 0:
             self.current_page_num -= 1
         else:
             self.current_page_num = self.page_count - 1
-        self.set_page()
+        self.setPage()
 
-    def set_page(self) -> None:
-        if not self.metadata.is_empty:
-            archive_page_index = self.metadata.get_archive_page_index(self.current_page_num)
+    def setPage(self):
+        if self.metadata is not None:
+            archive_page_index = self.metadata.getArchivePageIndex(self.current_page_num)
         else:
             archive_page_index = self.current_page_num
 
-        self.pageWidget.set_page(archive_page_index)
-        self.setWindowTitle(f"Page Browser - Page {self.current_page_num + 1} (of {self.page_count}) ")
+        self.pageWidget.setPage(archive_page_index)
+        self.setWindowTitle("Page Browser - Page {0} (of {1}) ".format(self.current_page_num + 1, self.page_count))

comictaggerlib/pagelisteditor.py

@@ -1,55 +1,62 @@
 """A PyQt5 widget for editing the page list info"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import logging
+import sys
+from operator import attrgetter, itemgetter
 
-from PyQt5 import QtCore, QtGui, QtWidgets, uic
+from PyQt5 import uic
+from PyQt5.QtCore import *
+from PyQt5.QtGui import *
+from PyQt5.QtWidgets import *
 
-from comicapi.comicarchive import ComicArchive, MetaDataStyle
-from comicapi.genericmetadata import ImageMetadata, PageType
-from comictaggerlib.coverimagewidget import CoverImageWidget
-from comictaggerlib.ui import ui_path
-
-logger = logging.getLogger(__name__)
+from .comicarchive import MetaDataStyle
+from .coverimagewidget import CoverImageWidget
+from .genericmetadata import GenericMetadata, PageType
+from .settings import ComicTaggerSettings
 
 
-def item_move_events(widget: QtWidgets.QWidget) -> QtCore.pyqtBoundSignal:
-    class Filter(QtCore.QObject):
-        mysignal = QtCore.pyqtSignal(str)
+def itemMoveEvents(widget):
+    class Filter(QObject):
+
+        mysignal = pyqtSignal(str)
+
+        def eventFilter(self, obj, event):
 
-        def eventFilter(self, obj: QtCore.QObject, event: QtCore.QEvent) -> bool:
             if obj == widget:
-                if event.type() == QtCore.QEvent.Type.ChildRemoved:
+                # print(event.type())
+                if event.type() == QEvent.ChildRemoved:
+                    # print("ChildRemoved")
                     self.mysignal.emit("finish")
-                if event.type() == QtCore.QEvent.Type.ChildAdded:
+                if event.type() == QEvent.ChildAdded:
+                    # print("ChildAdded")
                     self.mysignal.emit("start")
                     return True
 
             return False
 
-    filt = Filter(widget)
-    widget.installEventFilter(filt)
-    return filt.mysignal
+    filter = Filter(widget)
+    widget.installEventFilter(filter)
+    return filter.mysignal
 
 
-class PageListEditor(QtWidgets.QWidget):
-    firstFrontCoverChanged = QtCore.pyqtSignal(int)
-    listOrderChanged = QtCore.pyqtSignal()
-    modified = QtCore.pyqtSignal()
+class PageListEditor(QWidget):
+
+    firstFrontCoverChanged = pyqtSignal(int)
+    listOrderChanged = pyqtSignal()
+    modified = pyqtSignal()
 
     pageTypeNames = {
         PageType.FrontCover: "Front Cover",
@@ -65,125 +72,115 @@ class PageListEditor(QtWidgets.QWidget):
         PageType.Deleted: "Deleted",
     }
 
-    def __init__(self, parent: QtWidgets.QWidget) -> None:
-        super().__init__(parent)
+    def __init__(self, parent):
+        super(PageListEditor, self).__init__(parent)
 
-        uic.loadUi(ui_path / "pagelisteditor.ui", self)
+        uic.loadUi(ComicTaggerSettings.getUIFile("pagelisteditor.ui"), self)
 
-        self.pageWidget = CoverImageWidget(self.pageContainer, CoverImageWidget.ArchiveMode, None, None)
-        gridlayout = QtWidgets.QGridLayout(self.pageContainer)
+        self.setEnabled(True)
+        self.pageWidget = CoverImageWidget(self.pageContainer, CoverImageWidget.ArchiveMode)
+        gridlayout = QGridLayout(self.pageContainer)
         gridlayout.addWidget(self.pageWidget)
         gridlayout.setContentsMargins(0, 0, 0, 0)
         self.pageWidget.showControls = False
 
-        self.reset_page()
+        self.resetPage()
 
-        # Add the entries to the page type combobox
-        self.add_page_type_item("", "", "Alt+0", False)
-        self.add_page_type_item(self.pageTypeNames[PageType.FrontCover], PageType.FrontCover, "Alt+F")
-        self.add_page_type_item(self.pageTypeNames[PageType.InnerCover], PageType.InnerCover, "Alt+I")
-        self.add_page_type_item(self.pageTypeNames[PageType.Advertisement], PageType.Advertisement, "Alt+A")
-        self.add_page_type_item(self.pageTypeNames[PageType.Roundup], PageType.Roundup, "Alt+R")
-        self.add_page_type_item(self.pageTypeNames[PageType.Story], PageType.Story, "Alt+S")
-        self.add_page_type_item(self.pageTypeNames[PageType.Editorial], PageType.Editorial, "Alt+E")
-        self.add_page_type_item(self.pageTypeNames[PageType.Letters], PageType.Letters, "Alt+L")
-        self.add_page_type_item(self.pageTypeNames[PageType.Preview], PageType.Preview, "Alt+P")
-        self.add_page_type_item(self.pageTypeNames[PageType.BackCover], PageType.BackCover, "Alt+B")
-        self.add_page_type_item(self.pageTypeNames[PageType.Other], PageType.Other, "Alt+O")
-        self.add_page_type_item(self.pageTypeNames[PageType.Deleted], PageType.Deleted, "Alt+X")
+        # Add the entries to the manga combobox
+        self.comboBox.addItem("", "")
+        self.comboBox.addItem(self.pageTypeNames[PageType.FrontCover], PageType.FrontCover)
+        self.comboBox.addItem(self.pageTypeNames[PageType.InnerCover], PageType.InnerCover)
+        self.comboBox.addItem(self.pageTypeNames[PageType.Advertisement], PageType.Advertisement)
+        self.comboBox.addItem(self.pageTypeNames[PageType.Roundup], PageType.Roundup)
+        self.comboBox.addItem(self.pageTypeNames[PageType.Story], PageType.Story)
+        self.comboBox.addItem(self.pageTypeNames[PageType.Editorial], PageType.Editorial)
+        self.comboBox.addItem(self.pageTypeNames[PageType.Letters], PageType.Letters)
+        self.comboBox.addItem(self.pageTypeNames[PageType.Preview], PageType.Preview)
+        self.comboBox.addItem(self.pageTypeNames[PageType.BackCover], PageType.BackCover)
+        self.comboBox.addItem(self.pageTypeNames[PageType.Other], PageType.Other)
+        self.comboBox.addItem(self.pageTypeNames[PageType.Deleted], PageType.Deleted)
 
-        self.listWidget.itemSelectionChanged.connect(self.change_page)
-        item_move_events(self.listWidget).connect(self.item_move_event)
-        self.cbPageType.activated.connect(self.change_page_type)
-        self.chkDoublePage.clicked.connect(self.toggle_double_page)
-        self.leBookmark.editingFinished.connect(self.save_bookmark)
-        self.btnUp.clicked.connect(self.move_current_up)
-        self.btnDown.clicked.connect(self.move_current_down)
+        self.listWidget.itemSelectionChanged.connect(self.changePage)
+        itemMoveEvents(self.listWidget).connect(self.itemMoveEvent)
+        self.comboBox.activated.connect(self.changePageType)
+        self.btnUp.clicked.connect(self.moveCurrentUp)
+        self.btnDown.clicked.connect(self.moveCurrentDown)
         self.pre_move_row = -1
-        self.first_front_page: int | None = None
+        self.first_front_page = None
 
-        self.comic_archive: ComicArchive | None = None
-        self.pages_list: list[ImageMetadata] = []
+    def toggleAd(self):
+        ad = self.comboBox.findData(PageType.Advertisement)
+        if self.comboBox.currentIndex() == ad:
+            self.comboBox.setCurrentIndex(0)
+            self.changePageType(0)
+        else:
+            self.comboBox.setCurrentIndex(ad)
+            self.changePageType(ad)
 
-    def reset_page(self) -> None:
+    def resetPage(self):
         self.pageWidget.clear()
-        self.cbPageType.setDisabled(True)
-        self.chkDoublePage.setDisabled(True)
-        self.leBookmark.setDisabled(True)
+        self.comboBox.setDisabled(True)
         self.comic_archive = None
-        self.pages_list = []
+        self.pages_list = None
 
-    def add_page_type_item(self, text: str, user_data: str, shortcut: str, show_shortcut: bool = True) -> None:
-        if show_shortcut:
-            text = text + " (" + shortcut + ")"
-        self.cbPageType.addItem(text, user_data)
-        action_item = QtWidgets.QAction(shortcut, self)
-        action_item.triggered.connect(lambda: self.select_page_type_item(self.cbPageType.findData(user_data)))
-        action_item.setShortcut(shortcut)
-        self.addAction(action_item)
-
-    def select_page_type_item(self, idx: int) -> None:
-        if self.cbPageType.isEnabled():
-            self.cbPageType.setCurrentIndex(idx)
-            self.change_page_type(idx)
-
-    def get_new_indexes(self, movement: int) -> list[tuple[int, int]]:
+    def getNewIndexes(self, movement):
         selection = self.listWidget.selectionModel().selectedRows()
         selection.sort(reverse=movement > 0)
-        new_indexes: list[int] = []
-        old_indexes: list[int] = []
+        current = 0
+        newindexes = []
+        oldindexes = []
         for x in selection:
             current = x.row()
-            old_indexes.append(current)
-            if 0 <= current + movement <= self.listWidget.count() - 1:
-                if len(new_indexes) < 1 or current + movement != new_indexes[-1]:
+            oldindexes.append(current)
+            if current + movement >= 0 and current + movement <= self.listWidget.count() - 1:
+                if len(newindexes) < 1 or current + movement != newindexes[-1]:
                     current += movement
+            else:
+                prev = current
+            newindexes.append(current)
+        oldindexes.sort()
+        newindexes.sort()
+        return list(zip(newindexes, oldindexes))
 
-            new_indexes.append(current)
-        old_indexes.sort()
-        new_indexes.sort()
-        return list(zip(new_indexes, old_indexes))
-
-    def set_selection(self, indexes: list[tuple[int, int]]) -> list[tuple[int, int]]:
-        selection_ranges: list[tuple[int, int]] = []
+    def SetSelection(self, indexes):
+        selectionRanges = []
         first = 0
-        for i, sel in enumerate(indexes):
+        for i, selection in enumerate(indexes):
             if i == 0:
-                first = sel[0]
+                first = selection[0]
                 continue
 
-            if sel[0] != indexes[i - 1][0] + 1:
-                selection_ranges.append((first, indexes[i - 1][0]))
-                first = sel[0]
+            if selection != indexes[i - 1][0] + 1:
+                selectionRanges.append((first, indexes[i - 1][0]))
+                first = selection[0]
 
-        selection_ranges.append((first, indexes[-1][0]))
-        selection = QtCore.QItemSelection()
-        for x in selection_ranges:
+        selectionRanges.append((first, indexes[-1][0]))
+        selection = QItemSelection()
+        for x in selectionRanges:
             selection.merge(
-                QtCore.QItemSelection(self.listWidget.model().index(x[0], 0), self.listWidget.model().index(x[1], 0)),
-                QtCore.QItemSelectionModel.SelectionFlag.Select,
+                QItemSelection(self.listWidget.model().index(x[0], 0), self.listWidget.model().index(x[1], 0)), QItemSelectionModel.Select
             )
 
-        self.listWidget.selectionModel().select(selection, QtCore.QItemSelectionModel.SelectionFlag.ClearAndSelect)
-        return selection_ranges
+        self.listWidget.selectionModel().select(selection, QItemSelectionModel.ClearAndSelect)
+        return selectionRanges
 
-    def move_current_up(self) -> None:
+    def moveCurrentUp(self):
         row = self.listWidget.currentRow()
-        selection = self.get_new_indexes(-1)
+        selection = self.getNewIndexes(-1)
         for sel in selection:
             item = self.listWidget.takeItem(sel[1])
             self.listWidget.insertItem(sel[0], item)
 
         if row > 0:
             self.listWidget.setCurrentRow(row - 1)
-        self.set_selection(selection)
+        self.SetSelection(selection)
         self.listOrderChanged.emit()
-        self.emit_front_cover_change()
+        self.emitFrontCoverChange()
         self.modified.emit()
 
-    def move_current_down(self) -> None:
+    def moveCurrentDown(self):
         row = self.listWidget.currentRow()
-        selection = self.get_new_indexes(1)
+        selection = self.getNewIndexes(1)
         selection.sort(reverse=True)
         for sel in selection:
             item = self.listWidget.takeItem(sel[1])
@@ -192,205 +189,139 @@ class PageListEditor(QtWidgets.QWidget):
         if row < self.listWidget.count() - 1:
             self.listWidget.setCurrentRow(row + 1)
         self.listOrderChanged.emit()
-        self.emit_front_cover_change()
-        self.set_selection(selection)
+        self.emitFrontCoverChange()
+        self.SetSelection(selection)
         self.modified.emit()
 
-    def item_move_event(self, s: str) -> None:
+    def itemMoveEvent(self, s):
+        # print "move event: ", s, self.listWidget.currentRow()
         if s == "start":
             self.pre_move_row = self.listWidget.currentRow()
         if s == "finish":
             if self.pre_move_row != self.listWidget.currentRow():
                 self.listOrderChanged.emit()
-                self.emit_front_cover_change()
+                self.emitFrontCoverChange()
                 self.modified.emit()
 
-    def change_page_type(self, i: int) -> None:
-        new_type = self.cbPageType.itemData(i)
-        if self.get_current_page_type() != new_type:
-            self.set_current_page_type(new_type)
-            self.emit_front_cover_change()
+    def changePageType(self, i):
+        new_type = self.comboBox.itemData(i)
+        if self.getCurrentPageType() != new_type:
+            self.setCurrentPageType(new_type)
+            self.emitFrontCoverChange()
             self.modified.emit()
 
-    def change_page(self) -> None:
+    def changePage(self):
         row = self.listWidget.currentRow()
-        pagetype = self.get_current_page_type()
+        pagetype = self.getCurrentPageType()
 
-        i = self.cbPageType.findData(pagetype)
-        self.cbPageType.setCurrentIndex(i)
+        i = self.comboBox.findData(pagetype)
+        self.comboBox.setCurrentIndex(i)
 
-        self.chkDoublePage.setChecked("DoublePage" in self.listWidget.item(row).data(QtCore.Qt.UserRole)[0])
-
-        if "Bookmark" in self.listWidget.item(row).data(QtCore.Qt.UserRole)[0]:
-            self.leBookmark.setText(self.listWidget.item(row).data(QtCore.Qt.UserRole)[0]["Bookmark"])
-        else:
-            self.leBookmark.setText("")
-
-        idx = int(self.listWidget.item(row).data(QtCore.Qt.ItemDataRole.UserRole)[0]["Image"])
+        # idx = int(str (self.listWidget.item(row).text()))
+        idx = int(self.listWidget.item(row).data(Qt.UserRole)[0]["Image"])
 
         if self.comic_archive is not None:
-            self.pageWidget.set_archive(self.comic_archive, idx)
+            self.pageWidget.setArchive(self.comic_archive, idx)
 
-    def get_first_front_cover(self) -> int:
-        front_cover = 0
+    def getFirstFrontCover(self):
+        frontCover = 0
         for i in range(self.listWidget.count()):
             item = self.listWidget.item(i)
-            page_dict: ImageMetadata = item.data(QtCore.Qt.ItemDataRole.UserRole)[0]
+            page_dict = item.data(Qt.UserRole)[0]  # .toPyObject()[0]
             if "Type" in page_dict and page_dict["Type"] == PageType.FrontCover:
-                front_cover = int(page_dict["Image"])
+                frontCover = int(page_dict["Image"])
                 break
-        return front_cover
+        return frontCover
 
-    def get_current_page_type(self) -> str:
+    def getCurrentPageType(self):
         row = self.listWidget.currentRow()
-        page_dict: ImageMetadata = self.listWidget.item(row).data(QtCore.Qt.ItemDataRole.UserRole)[0]
+        page_dict = self.listWidget.item(row).data(Qt.UserRole)[0]  # .toPyObject()[0]
         if "Type" in page_dict:
             return page_dict["Type"]
+        else:
+            return ""
 
-        return ""
-
-    def set_current_page_type(self, t: str) -> None:
+    def setCurrentPageType(self, t):
         row = self.listWidget.currentRow()
-        page_dict: ImageMetadata = self.listWidget.item(row).data(QtCore.Qt.ItemDataRole.UserRole)[0]
+        page_dict = self.listWidget.item(row).data(Qt.UserRole)[0]  # .toPyObject()[0]
 
         if t == "":
             if "Type" in page_dict:
                 del page_dict["Type"]
         else:
-            page_dict["Type"] = t
-
-        item = self.listWidget.item(row)
-        # wrap the dict in a tuple to keep from being converted to QtWidgets.QStrings
-        item.setData(QtCore.Qt.ItemDataRole.UserRole, (page_dict,))
-        item.setText(self.list_entry_text(page_dict))
-
-    def toggle_double_page(self) -> None:
-        row = self.listWidget.currentRow()
-        page_dict: ImageMetadata = self.listWidget.item(row).data(QtCore.Qt.UserRole)[0]
-
-        cbx = self.sender()
-
-        if isinstance(cbx, QtWidgets.QCheckBox) and cbx.isChecked():
-            if "DoublePage" not in page_dict:
-                page_dict["DoublePage"] = True
-                self.modified.emit()
-        elif "DoublePage" in page_dict:
-            del page_dict["DoublePage"]
-            self.modified.emit()
+            page_dict["Type"] = str(t)
 
         item = self.listWidget.item(row)
         # wrap the dict in a tuple to keep from being converted to QStrings
-        item.setData(QtCore.Qt.UserRole, (page_dict,))
-        item.setText(self.list_entry_text(page_dict))
+        item.setData(Qt.UserRole, (page_dict,))
+        item.setText(self.listEntryText(page_dict))
 
-        self.listWidget.setFocus()
-
-    def save_bookmark(self) -> None:
-        row = self.listWidget.currentRow()
-        page_dict: ImageMetadata = self.listWidget.item(row).data(QtCore.Qt.UserRole)[0]
-
-        current_bookmark = ""
-        if "Bookmark" in page_dict:
-            current_bookmark = page_dict["Bookmark"]
-
-        if self.leBookmark.text().strip():
-            new_bookmark = str(self.leBookmark.text().strip())
-            if current_bookmark != new_bookmark:
-                page_dict["Bookmark"] = new_bookmark
-                self.modified.emit()
-        elif current_bookmark != "":
-            del page_dict["Bookmark"]
-            self.modified.emit()
-
-        item = self.listWidget.item(row)
-        # wrap the dict in a tuple to keep from being converted to QStrings
-        item.setData(QtCore.Qt.UserRole, (page_dict,))
-        item.setText(self.list_entry_text(page_dict))
-
-        self.listWidget.setFocus()
-
-    def set_data(self, comic_archive: ComicArchive, pages_list: list[ImageMetadata]) -> None:
+    def setData(self, comic_archive, pages_list):
         self.comic_archive = comic_archive
         self.pages_list = pages_list
         if pages_list is not None and len(pages_list) > 0:
-            self.cbPageType.setDisabled(False)
-            self.chkDoublePage.setDisabled(False)
-            self.leBookmark.setDisabled(False)
+            self.comboBox.setDisabled(False)
 
-        self.listWidget.itemSelectionChanged.disconnect(self.change_page)
+        self.listWidget.itemSelectionChanged.disconnect(self.changePage)
 
         self.listWidget.clear()
         for p in pages_list:
-            item = QtWidgets.QListWidgetItem(self.list_entry_text(p))
-            # wrap the dict in a tuple to keep from being converted to QtWidgets.QStrings
-            item.setData(QtCore.Qt.ItemDataRole.UserRole, (p,))
+            item = QListWidgetItem(self.listEntryText(p))
+            # wrap the dict in a tuple to keep from being converted to QStrings
+            item.setData(Qt.UserRole, (p,))
 
             self.listWidget.addItem(item)
-        self.first_front_page = self.get_first_front_cover()
-        self.listWidget.itemSelectionChanged.connect(self.change_page)
+        self.first_front_page = self.getFirstFrontCover()
+        self.listWidget.itemSelectionChanged.connect(self.changePage)
         self.listWidget.setCurrentRow(0)
 
-    def list_entry_text(self, page_dict: ImageMetadata) -> str:
+    def listEntryText(self, page_dict):
         text = str(int(page_dict["Image"]) + 1)
         if "Type" in page_dict:
-            if page_dict["Type"] in self.pageTypeNames:
-                text += " (" + self.pageTypeNames[page_dict["Type"]] + ")"
-            else:
-                text += " (Error: " + page_dict["Type"] + ")"
-        if "DoublePage" in page_dict:
-            text += " ②"
-        if "Bookmark" in page_dict:
-            text += " 🔖"
+            text += " (" + self.pageTypeNames[page_dict["Type"]] + ")"
         return text
 
-    def get_page_list(self) -> list[ImageMetadata]:
+    def getPageList(self):
         page_list = []
         for i in range(self.listWidget.count()):
             item = self.listWidget.item(i)
-            page_list.append(item.data(QtCore.Qt.ItemDataRole.UserRole)[0])
+            page_list.append(item.data(Qt.UserRole)[0])  # .toPyObject()[0]
         return page_list
 
-    def emit_front_cover_change(self) -> None:
-        if self.first_front_page != self.get_first_front_cover():
-            self.first_front_page = self.get_first_front_cover()
+    def emitFrontCoverChange(self):
+        if self.first_front_page != self.getFirstFrontCover():
+            self.first_front_page = self.getFirstFrontCover()
             self.firstFrontCoverChanged.emit(self.first_front_page)
 
-    def set_metadata_style(self, data_style: int) -> None:
+    def setMetadataStyle(self, data_style):
+
         # depending on the current data style, certain fields are disabled
 
-        inactive_color = QtGui.QColor(255, 170, 150)
-        active_palette = self.cbPageType.palette()
+        inactive_color = QColor(255, 170, 150)
+        active_palette = self.comboBox.palette()
 
-        inactive_palette3 = self.cbPageType.palette()
-        inactive_palette3.setColor(QtGui.QPalette.ColorRole.Base, inactive_color)
+        inactive_palette3 = self.comboBox.palette()
+        inactive_palette3.setColor(QPalette.Base, inactive_color)
 
         if data_style == MetaDataStyle.CIX:
             self.btnUp.setEnabled(True)
             self.btnDown.setEnabled(True)
-            self.cbPageType.setEnabled(True)
-            self.chkDoublePage.setEnabled(True)
-            self.leBookmark.setEnabled(True)
+            self.comboBox.setEnabled(True)
             self.listWidget.setEnabled(True)
 
-            self.leBookmark.setPalette(active_palette)
             self.listWidget.setPalette(active_palette)
 
         elif data_style == MetaDataStyle.CBI:
             self.btnUp.setEnabled(False)
             self.btnDown.setEnabled(False)
-            self.cbPageType.setEnabled(False)
-            self.chkDoublePage.setEnabled(False)
-            self.leBookmark.setEnabled(False)
+            self.comboBox.setEnabled(False)
             self.listWidget.setEnabled(False)
 
-            self.leBookmark.setPalette(inactive_palette3)
             self.listWidget.setPalette(inactive_palette3)
 
-        elif data_style == MetaDataStyle.COMET:
+        elif data_style == MetaDataStyle.CoMet:
             pass
 
         # make sure combo is disabled when no list
         if self.comic_archive is None:
-            self.cbPageType.setEnabled(False)
-            self.chkDoublePage.setEnabled(False)
-            self.leBookmark.setEnabled(False)
+            self.comboBox.setEnabled(False)

comictaggerlib/pageloader.py

@@ -1,30 +1,27 @@
 """A PyQT4 class to load a page image from a ComicArchive in a background thread"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import logging
+from PyQt5 import QtCore, QtGui, uic
+from PyQt5.QtCore import pyqtSignal
 
-from PyQt5 import QtCore
-
-from comicapi.comicarchive import ComicArchive
-
-logger = logging.getLogger(__name__)
+from comictaggerlib.ui.qtutils import getQImageFromData
 
 
 class PageLoader(QtCore.QThread):
+
     """
     This class holds onto a reference of each instance in a list since
     problems occur if the ref count goes to zero and the GC tries to reap
@@ -33,36 +30,39 @@ class PageLoader(QtCore.QThread):
     "abandoned", and no signals will be issued.
     """
 
-    loadComplete = QtCore.pyqtSignal(bytes)
+    loadComplete = pyqtSignal(QtGui.QImage)
 
-    instanceList: list[QtCore.QThread] = []
+    instanceList = []
     mutex = QtCore.QMutex()
 
     # Remove all finished threads from the list
     @staticmethod
-    def reap_instances() -> None:
+    def reapInstances():
         for obj in reversed(PageLoader.instanceList):
             if obj.isFinished():
                 PageLoader.instanceList.remove(obj)
 
-    def __init__(self, ca: ComicArchive, page_num: int) -> None:
+    def __init__(self, ca, page_num):
         QtCore.QThread.__init__(self)
-        self.ca: ComicArchive = ca
-        self.page_num: int = page_num
+        self.ca = ca
+        self.page_num = page_num
         self.abandoned = False
 
         # remove any old instances, and then add ourself
         PageLoader.mutex.lock()
-        PageLoader.reap_instances()
+        PageLoader.reapInstances()
         PageLoader.instanceList.append(self)
         PageLoader.mutex.unlock()
 
-    def run(self) -> None:
-        image_data = self.ca.get_page(self.page_num)
+    def run(self):
+        image_data = self.ca.getPage(self.page_num)
         if self.abandoned:
             return
 
-        if image_data:
+        if image_data is not None:
+            img = getQImageFromData(image_data)
+
             if self.abandoned:
                 return
-            self.loadComplete.emit(image_data)
+
+            self.loadComplete.emit(img)

comictaggerlib/progresswindow.py

@@ -1,42 +1,33 @@
-"""A PyQt5 dialog to show ID log and progress"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+"""A PyQT5 dialog to show ID log and progress"""
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import logging
 
-from PyQt5 import QtCore, QtWidgets, uic
+from PyQt5 import QtCore, QtGui, QtWidgets, uic
 
-from comictaggerlib.ui import ui_path
-from comictaggerlib.ui.qtutils import reduce_widget_font_size
+from comictaggerlib.ui.qtutils import reduceWidgetFontSize
 
-logger = logging.getLogger(__name__)
+from .settings import ComicTaggerSettings
 
 
 class IDProgressWindow(QtWidgets.QDialog):
-    def __init__(self, parent: QtWidgets.QWidget) -> None:
-        super().__init__(parent)
+    def __init__(self, parent):
+        super(IDProgressWindow, self).__init__(parent)
 
-        uic.loadUi(ui_path / "progresswindow.ui", self)
+        uic.loadUi(ComicTaggerSettings.getUIFile("progresswindow.ui"), self)
 
-        self.setWindowFlags(
-            QtCore.Qt.WindowType(
-                self.windowFlags()
-                | QtCore.Qt.WindowType.WindowSystemMenuHint
-                | QtCore.Qt.WindowType.WindowMaximizeButtonHint
-            )
-        )
+        self.setWindowFlags(self.windowFlags() | QtCore.Qt.WindowSystemMenuHint | QtCore.Qt.WindowMaximizeButtonHint)
 
-        reduce_widget_font_size(self.textEdit)
+        reduceWidgetFontSize(self.textEdit)

comictaggerlib/renamewindow.py

@@ -1,129 +1,91 @@
 """A PyQT4 dialog to confirm rename"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import logging
+import os
 
-import settngs
-from PyQt5 import QtCore, QtWidgets, uic
+from PyQt5 import QtCore, QtGui, QtWidgets, uic
 
-from comicapi import utils
-from comicapi.comicarchive import ComicArchive, MetaDataStyle
-from comicapi.genericmetadata import GenericMetadata
-from comictaggerlib.filerenamer import FileRenamer, get_rename_dir
-from comictaggerlib.settingswindow import SettingsWindow
-from comictaggerlib.ui import ui_path
-from comictaggerlib.ui.qtutils import center_window_on_parent
-from comictalker.comictalker import ComicTalker
+from comictaggerlib.ui.qtutils import centerWindowOnParent
 
-logger = logging.getLogger(__name__)
+from . import utils
+from .comicarchive import MetaDataStyle
+from .filerenamer import FileRenamer
+from .settings import ComicTaggerSettings
+from .settingswindow import SettingsWindow
 
 
 class RenameWindow(QtWidgets.QDialog):
-    def __init__(
-        self,
-        parent: QtWidgets.QWidget,
-        comic_archive_list: list[ComicArchive],
-        data_style: int,
-        config: settngs.Config[settngs.Namespace],
-        talkers: dict[str, ComicTalker],
-    ) -> None:
-        super().__init__(parent)
+    def __init__(self, parent, comic_archive_list, data_style, settings):
+        super(RenameWindow, self).__init__(parent)
 
-        uic.loadUi(ui_path / "renamewindow.ui", self)
-        self.label.setText(f"Preview (based on {MetaDataStyle.name[data_style]} tags):")
+        uic.loadUi(ComicTaggerSettings.getUIFile("renamewindow.ui"), self)
+        self.label.setText("Preview (based on {0} tags):".format(MetaDataStyle.name[data_style]))
 
-        self.setWindowFlags(
-            QtCore.Qt.WindowType(
-                self.windowFlags()
-                | QtCore.Qt.WindowType.WindowSystemMenuHint
-                | QtCore.Qt.WindowType.WindowMaximizeButtonHint
-            )
-        )
+        self.setWindowFlags(self.windowFlags() | QtCore.Qt.WindowSystemMenuHint | QtCore.Qt.WindowMaximizeButtonHint)
 
-        self.config = config
-        self.talkers = talkers
+        self.settings = settings
         self.comic_archive_list = comic_archive_list
         self.data_style = data_style
-        self.rename_list: list[str] = []
 
-        self.btnSettings.clicked.connect(self.modify_settings)
-        platform = "universal" if self.config[0].rename_strict else "auto"
-        self.renamer = FileRenamer(None, platform=platform, replacements=self.config[0].rename_replacements)
+        self.btnSettings.clicked.connect(self.modifySettings)
+        self.configRenamer()
+        self.doPreview()
 
-        self.do_preview()
+    def configRenamer(self):
+        self.renamer = FileRenamer(None)
+        self.renamer.setTemplate(self.settings.rename_template)
+        self.renamer.setIssueZeroPadding(self.settings.rename_issue_number_padding)
+        self.renamer.setSmartCleanup(self.settings.rename_use_smart_string_cleanup)
 
-    def config_renamer(self, ca: ComicArchive, md: GenericMetadata | None = None) -> str:
-        self.renamer.set_template(self.config[0].rename_template)
-        self.renamer.set_issue_zero_padding(self.config[0].rename_issue_number_padding)
-        self.renamer.set_smart_cleanup(self.config[0].rename_use_smart_string_cleanup)
-        self.renamer.replacements = self.config[0].rename_replacements
-
-        new_ext = ca.path.suffix  # default
-        if self.config[0].rename_set_extension_based_on_archive:
-            new_ext = ca.extension()
-
-        if md is None:
-            md = ca.read_metadata(self.data_style)
-            if md.is_empty:
-                md = ca.metadata_from_filename(
-                    self.config[0].filename_complicated_parser,
-                    self.config[0].filename_remove_c2c,
-                    self.config[0].filename_remove_fcbd,
-                    self.config[0].filename_remove_publisher,
-                )
-        self.renamer.set_metadata(md)
-        self.renamer.move = self.config[0].rename_move_to_dir
-        return new_ext
-
-    def do_preview(self) -> None:
-        self.twList.setRowCount(0)
+    def doPreview(self):
+        self.rename_list = []
+        while self.twList.rowCount() > 0:
+            self.twList.removeRow(0)
 
         self.twList.setSortingEnabled(False)
 
         for ca in self.comic_archive_list:
-            new_ext = self.config_renamer(ca)
+
+            new_ext = None  # default
+            if self.settings.rename_extension_based_on_archive:
+                if ca.isZip():
+                    new_ext = ".cbz"
+                elif ca.isRar():
+                    new_ext = ".cbr"
+
+            md = ca.readMetadata(self.data_style)
+            if md.isEmpty:
+                md = ca.metadataFromFilename(self.settings.parse_scan_info)
+            self.renamer.setMetadata(md)
+            self.renamer.move = self.settings.rename_move_dir
+
             try:
-                new_name = self.renamer.determine_name(new_ext)
-            except ValueError as e:
-                logger.exception("Invalid format string: %s", self.config[0].rename_template)
+                new_name = self.renamer.determineName(ca.path, ext=new_ext)
+            except Exception as e:
                 QtWidgets.QMessageBox.critical(
                     self,
                     "Invalid format string!",
                     "Your rename template is invalid!"
-                    f"<br/><br/>{e}<br/><br/>"
+                    "<br/><br/>{}<br/><br/>"
                     "Please consult the template help in the "
                     "settings and the documentation on the format at "
                     "<a href='https://docs.python.org/3/library/string.html#format-string-syntax'>"
-                    "https://docs.python.org/3/library/string.html#format-string-syntax</a>",
+                    "https://docs.python.org/3/library/string.html#format-string-syntax</a>".format(e),
                 )
                 return
-            except Exception as e:
-                logger.exception(
-                    "Formatter failure: %s metadata: %s", self.config[0].rename_template, self.renamer.metadata
-                )
-                QtWidgets.QMessageBox.critical(
-                    self,
-                    "The formatter had an issue!",
-                    "The formatter has experienced an unexpected error!"
-                    f"<br/><br/>{type(e).__name__}: {e}<br/><br/>"
-                    "Please open an issue at "
-                    "<a href='https://github.com/comictagger/comictagger'>"
-                    "https://github.com/comictagger/comictagger</a>",
-                )
 
             row = self.twList.rowCount()
             self.twList.insertRow(row)
@@ -131,24 +93,27 @@ class RenameWindow(QtWidgets.QDialog):
             old_name_item = QtWidgets.QTableWidgetItem()
             new_name_item = QtWidgets.QTableWidgetItem()
 
-            item_text = str(ca.path.parent)
-            folder_item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
+            item_text = os.path.split(ca.path)[0]
+            folder_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
             self.twList.setItem(row, 0, folder_item)
             folder_item.setText(item_text)
-            folder_item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
+            folder_item.setData(QtCore.Qt.ToolTipRole, item_text)
 
-            item_text = str(ca.path.name)
-            old_name_item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
+            item_text = os.path.split(ca.path)[1]
+            old_name_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
             self.twList.setItem(row, 1, old_name_item)
             old_name_item.setText(item_text)
-            old_name_item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
+            old_name_item.setData(QtCore.Qt.ToolTipRole, item_text)
 
-            new_name_item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
+            new_name_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
             self.twList.setItem(row, 2, new_name_item)
             new_name_item.setText(new_name)
-            new_name_item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, new_name)
+            new_name_item.setData(QtCore.Qt.ToolTipRole, new_name)
 
-            self.rename_list.append(new_name)
+            dict_item = dict()
+            dict_item["archive"] = ca
+            dict_item["new_name"] = new_name
+            self.rename_list.append(dict_item)
 
         # Adjust column sizes
         self.twList.setVisible(False)
@@ -159,57 +124,55 @@ class RenameWindow(QtWidgets.QDialog):
 
         self.twList.setSortingEnabled(True)
 
-    def modify_settings(self) -> None:
-        settingswin = SettingsWindow(self, self.config, self.talkers)
+    def modifySettings(self):
+        settingswin = SettingsWindow(self, self.settings)
         settingswin.setModal(True)
-        settingswin.show_rename_tab()
-        settingswin.exec()
+        settingswin.showRenameTab()
+        settingswin.exec_()
         if settingswin.result():
-            self.do_preview()
+            self.configRenamer()
+            self.doPreview()
 
-    def accept(self) -> None:
-        prog_dialog = QtWidgets.QProgressDialog("", "Cancel", 0, len(self.rename_list), self)
-        prog_dialog.setWindowTitle("Renaming Archives")
-        prog_dialog.setWindowModality(QtCore.Qt.WindowModality.WindowModal)
-        prog_dialog.setMinimumDuration(100)
-        center_window_on_parent(prog_dialog)
+    def accept(self):
+
+        progdialog = QtWidgets.QProgressDialog("", "Cancel", 0, len(self.rename_list), self)
+        progdialog.setWindowTitle("Renaming Archives")
+        progdialog.setWindowModality(QtCore.Qt.WindowModal)
+        progdialog.setMinimumDuration(100)
+        centerWindowOnParent(progdialog)
+        # progdialog.show()
         QtCore.QCoreApplication.processEvents()
 
-        try:
-            for idx, comic in enumerate(zip(self.comic_archive_list, self.rename_list)):
-                QtCore.QCoreApplication.processEvents()
-                if prog_dialog.wasCanceled():
-                    break
-                idx += 1
-                prog_dialog.setValue(idx)
-                prog_dialog.setLabelText(comic[1])
-                center_window_on_parent(prog_dialog)
-                QtCore.QCoreApplication.processEvents()
+        for idx, item in enumerate(self.rename_list):
 
-                folder = get_rename_dir(
-                    comic[0],
-                    self.config[0].rename_dir if self.config[0].rename_move_to_dir else None,
-                )
+            QtCore.QCoreApplication.processEvents()
+            if progdialog.wasCanceled():
+                break
+            idx += 1
+            progdialog.setValue(idx)
+            progdialog.setLabelText(item["new_name"])
+            centerWindowOnParent(progdialog)
+            QtCore.QCoreApplication.processEvents()
 
-                full_path = folder / comic[1]
+            folder = os.path.dirname(os.path.abspath(item["archive"].path))
+            if self.settings.rename_move_dir and len(self.settings.rename_dir.strip()) > 3:
+                folder = self.settings.rename_dir.strip()
 
-                if full_path == comic[0].path:
-                    logger.info("%s: Filename is already good!", comic[1])
-                    continue
+            new_abs_path = utils.unique_file(os.path.join(folder, item["new_name"]))
 
-                if not comic[0].is_writable(check_archive_status=False):
-                    continue
+            if os.path.join(folder, item["new_name"]) == item["archive"].path:
+                print(item["new_name"], "Filename is already good!")
+                continue
 
-                comic[0].rename(utils.unique_file(full_path))
-        except Exception as e:
-            logger.exception("Failed to rename comic archive: %s", comic[0].path)
-            QtWidgets.QMessageBox.critical(
-                self,
-                "There was an issue when renaming!",
-                f"Renaming failed!<br/><br/>{type(e).__name__}: {e}<br/><br/>",
-            )
+            if not item["archive"].isWritable(check_rar_status=False):
+                continue
 
-        prog_dialog.hide()
+            os.makedirs(os.path.dirname(new_abs_path), 0o777, True)
+            os.rename(item["archive"].path, new_abs_path)
+
+            item["archive"].rename(new_abs_path)
+
+        progdialog.hide()
         QtCore.QCoreApplication.processEvents()
 
         QtWidgets.QDialog.accept(self)

comictaggerlib/resulttypes.py

@@ -1,38 +0,0 @@
-from __future__ import annotations
-
-from typing_extensions import TypedDict
-
-from comicapi.comicarchive import ComicArchive
-
-
-class IssueResult(TypedDict):
-    series: str
-    distance: int
-    issue_number: str
-    cv_issue_count: int | None
-    url_image_hash: int
-    issue_title: str
-    issue_id: str
-    series_id: str
-    month: int | None
-    year: int | None
-    publisher: str | None
-    image_url: str
-    alt_image_urls: list[str]
-    description: str
-
-
-class OnlineMatchResults:
-    def __init__(self) -> None:
-        self.good_matches: list[str] = []
-        self.no_matches: list[str] = []
-        self.multiple_matches: list[MultipleMatch] = []
-        self.low_confidence_matches: list[MultipleMatch] = []
-        self.write_failures: list[str] = []
-        self.fetch_data_failures: list[str] = []
-
-
-class MultipleMatch:
-    def __init__(self, ca: ComicArchive, match_list: list[IssueResult]) -> None:
-        self.ca: ComicArchive = ca
-        self.matches: list[IssueResult] = match_list

comictaggerlib/seriesselectionwindow.py

@@ -1,536 +0,0 @@
-"""A PyQT4 dialog to select specific series/volume from list"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-from __future__ import annotations
-
-import itertools
-import logging
-from collections import deque
-
-import settngs
-from PyQt5 import QtCore, QtGui, QtWidgets, uic
-from PyQt5.QtCore import pyqtSignal
-
-from comicapi import utils
-from comicapi.comicarchive import ComicArchive
-from comicapi.genericmetadata import GenericMetadata
-from comictaggerlib.coverimagewidget import CoverImageWidget
-from comictaggerlib.issueidentifier import IssueIdentifier
-from comictaggerlib.issueselectionwindow import IssueSelectionWindow
-from comictaggerlib.matchselectionwindow import MatchSelectionWindow
-from comictaggerlib.progresswindow import IDProgressWindow
-from comictaggerlib.ui import ui_path
-from comictaggerlib.ui.qtutils import reduce_widget_font_size
-from comictalker.comictalker import ComicTalker, TalkerError
-from comictalker.resulttypes import ComicSeries
-
-logger = logging.getLogger(__name__)
-
-
-class SearchThread(QtCore.QThread):
-    searchComplete = pyqtSignal()
-    progressUpdate = pyqtSignal(int, int)
-
-    def __init__(
-        self, talker: ComicTalker, series_name: str, refresh: bool, literal: bool = False, series_match_thresh: int = 90
-    ) -> None:
-        QtCore.QThread.__init__(self)
-        self.talker = talker
-        self.series_name = series_name
-        self.refresh: bool = refresh
-        self.error_e: TalkerError
-        self.ct_error = False
-        self.ct_search_results: list[ComicSeries] = []
-        self.literal = literal
-        self.series_match_thresh = series_match_thresh
-
-    def run(self) -> None:
-        try:
-            self.ct_error = False
-            self.ct_search_results = self.talker.search_for_series(
-                self.series_name, self.prog_callback, self.refresh, self.literal, self.series_match_thresh
-            )
-        except TalkerError as e:
-            self.ct_search_results = []
-            self.ct_error = True
-            self.error_e = e
-
-        finally:
-            self.searchComplete.emit()
-
-    def prog_callback(self, current: int, total: int) -> None:
-        self.progressUpdate.emit(current, total)
-
-
-class IdentifyThread(QtCore.QThread):
-    identifyComplete = pyqtSignal()
-    identifyLogMsg = pyqtSignal(str)
-    identifyProgress = pyqtSignal(int, int)
-
-    def __init__(self, identifier: IssueIdentifier) -> None:
-        QtCore.QThread.__init__(self)
-        self.identifier = identifier
-        self.identifier.set_output_function(self.log_output)
-        self.identifier.set_progress_callback(self.progress_callback)
-
-    def log_output(self, text: str) -> None:
-        self.identifyLogMsg.emit(str(text))
-
-    def progress_callback(self, cur: int, total: int) -> None:
-        self.identifyProgress.emit(cur, total)
-
-    def run(self) -> None:
-        self.identifier.search()
-        self.identifyComplete.emit()
-
-
-class SeriesSelectionWindow(QtWidgets.QDialog):
-    def __init__(
-        self,
-        parent: QtWidgets.QWidget,
-        series_name: str,
-        issue_number: str,
-        year: int | None,
-        issue_count: int,
-        cover_index_list: list[int],
-        comic_archive: ComicArchive | None,
-        config: settngs.Namespace,
-        talker: ComicTalker,
-        autoselect: bool = False,
-        literal: bool = False,
-    ) -> None:
-        super().__init__(parent)
-
-        uic.loadUi(ui_path / "seriesselectionwindow.ui", self)
-
-        self.imageWidget = CoverImageWidget(
-            self.imageContainer, CoverImageWidget.URLMode, config.runtime_config.user_cache_dir, talker
-        )
-        gridlayout = QtWidgets.QGridLayout(self.imageContainer)
-        gridlayout.addWidget(self.imageWidget)
-        gridlayout.setContentsMargins(0, 0, 0, 0)
-
-        reduce_widget_font_size(self.teDetails, 1)
-        reduce_widget_font_size(self.twList)
-
-        self.setWindowFlags(
-            QtCore.Qt.WindowType(
-                self.windowFlags()
-                | QtCore.Qt.WindowType.WindowSystemMenuHint
-                | QtCore.Qt.WindowType.WindowMaximizeButtonHint
-            )
-        )
-
-        self.config = config
-        self.series_name = series_name
-        self.issue_number = issue_number
-        self.issue_id: str = ""
-        self.year = year
-        self.issue_count = issue_count
-        self.series_id: str = ""
-        self.comic_archive = comic_archive
-        self.immediate_autoselect = autoselect
-        self.cover_index_list = cover_index_list
-        self.ct_search_results: list[ComicSeries] = []
-        self.literal = literal
-        self.ii: IssueIdentifier | None = None
-        self.iddialog: IDProgressWindow | None = None
-        self.id_thread: IdentifyThread | None = None
-        self.progdialog: QtWidgets.QProgressDialog | None = None
-        self.search_thread: SearchThread | None = None
-
-        self.use_filter = self.config.identifier_always_use_publisher_filter
-
-        # Load to retrieve settings
-        self.talker = talker
-
-        # Display talker logo and set url
-        self.lblSourceName.setText(talker.attribution)
-
-        self.imageSourceWidget = CoverImageWidget(
-            self.imageSourceLogo,
-            CoverImageWidget.URLMode,
-            config.runtime_config.user_cache_dir,
-            talker,
-            False,
-        )
-        self.imageSourceWidget.showControls = False
-        gridlayoutSourceLogo = QtWidgets.QGridLayout(self.imageSourceLogo)
-        gridlayoutSourceLogo.addWidget(self.imageSourceWidget)
-        gridlayoutSourceLogo.setContentsMargins(0, 2, 0, 0)
-        self.imageSourceWidget.set_url(talker.logo_url)
-
-        # Set the minimum row height to the default.
-        # this way rows will be more consistent when resizeRowsToContents is called
-        self.twList.verticalHeader().setMinimumSectionSize(self.twList.verticalHeader().defaultSectionSize())
-        self.twList.currentItemChanged.connect(self.current_item_changed)
-        self.twList.cellDoubleClicked.connect(self.cell_double_clicked)
-        self.btnRequery.clicked.connect(self.requery)
-        self.btnIssues.clicked.connect(self.show_issues)
-        self.btnAutoSelect.clicked.connect(self.auto_select)
-
-        self.cbxFilter.setChecked(self.use_filter)
-        self.cbxFilter.toggled.connect(self.filter_toggled)
-
-        self.update_buttons()
-        self.twList.selectRow(0)
-
-    def update_buttons(self) -> None:
-        enabled = bool(self.ct_search_results)
-
-        self.btnRequery.setEnabled(enabled)
-
-        self.btnIssues.setEnabled(enabled)
-        self.btnAutoSelect.setEnabled(enabled)
-
-        self.buttonBox.button(QtWidgets.QDialogButtonBox.StandardButton.Ok).setEnabled(enabled)
-
-    def requery(self) -> None:
-        self.perform_query(refresh=True)
-        self.twList.selectRow(0)
-
-    def filter_toggled(self) -> None:
-        self.use_filter = not self.use_filter
-        self.perform_query(refresh=False)
-
-    def auto_select(self) -> None:
-        if self.comic_archive is None:
-            QtWidgets.QMessageBox.information(self, "Auto-Select", "You need to load a comic first!")
-            return
-
-        if self.issue_number is None or self.issue_number == "":
-            QtWidgets.QMessageBox.information(self, "Auto-Select", "Can't auto-select without an issue number (yet!)")
-            return
-
-        self.iddialog = IDProgressWindow(self)
-        self.iddialog.setModal(True)
-        self.iddialog.rejected.connect(self.identify_cancel)
-        self.iddialog.show()
-
-        self.ii = IssueIdentifier(self.comic_archive, self.config, self.talker)
-
-        md = GenericMetadata()
-        md.series = self.series_name
-        md.issue = self.issue_number
-        md.year = self.year
-        md.issue_count = self.issue_count
-
-        self.ii.set_additional_metadata(md)
-        self.ii.only_use_additional_meta_data = True
-
-        self.ii.cover_page_index = int(self.cover_index_list[0])
-
-        self.id_thread = IdentifyThread(self.ii)
-        self.id_thread.identifyComplete.connect(self.identify_complete)
-        self.id_thread.identifyLogMsg.connect(self.log_id_output)
-        self.id_thread.identifyProgress.connect(self.identify_progress)
-
-        self.id_thread.start()
-
-        self.iddialog.exec()
-
-    def log_id_output(self, text: str) -> None:
-        if self.iddialog is not None:
-            print(text, end=" ")  # noqa: T201
-            self.iddialog.textEdit.ensureCursorVisible()
-            self.iddialog.textEdit.insertPlainText(text)
-
-    def identify_progress(self, cur: int, total: int) -> None:
-        if self.iddialog is not None:
-            self.iddialog.progressBar.setMaximum(total)
-            self.iddialog.progressBar.setValue(cur)
-
-    def identify_cancel(self) -> None:
-        if self.ii is not None:
-            self.ii.cancel = True
-
-    def identify_complete(self) -> None:
-        if self.ii is not None and self.iddialog is not None and self.comic_archive is not None:
-            matches = self.ii.match_list
-            result = self.ii.search_result
-
-            found_match = None
-            choices = False
-            if result == self.ii.result_no_matches:
-                QtWidgets.QMessageBox.information(self, "Auto-Select Result", " No matches found :-(")
-            elif result == self.ii.result_found_match_but_bad_cover_score:
-                QtWidgets.QMessageBox.information(
-                    self,
-                    "Auto-Select Result",
-                    " Found a match, but cover doesn't seem the same.  Verify before committing!",
-                )
-                found_match = matches[0]
-            elif result == self.ii.result_found_match_but_not_first_page:
-                QtWidgets.QMessageBox.information(
-                    self, "Auto-Select Result", " Found a match, but not with the first page of the archive."
-                )
-                found_match = matches[0]
-            elif result == self.ii.result_multiple_matches_with_bad_image_scores:
-                QtWidgets.QMessageBox.information(
-                    self, "Auto-Select Result", " Found some possibilities, but no confidence. Proceed manually."
-                )
-                choices = True
-            elif result == self.ii.result_one_good_match:
-                found_match = matches[0]
-            elif result == self.ii.result_multiple_good_matches:
-                QtWidgets.QMessageBox.information(
-                    self, "Auto-Select Result", " Found multiple likely matches.  Please select."
-                )
-                choices = True
-
-            if choices:
-                selector = MatchSelectionWindow(
-                    self, matches, self.comic_archive, talker=self.talker, config=self.config
-                )
-                selector.setModal(True)
-                selector.exec()
-                if selector.result():
-                    # we should now have a list index
-                    found_match = selector.current_match()
-
-            if found_match is not None:
-                self.iddialog.accept()
-
-                self.series_id = utils.xlate(found_match["series_id"])
-                self.issue_number = found_match["issue_number"]
-                self.select_by_id()
-                self.show_issues()
-
-    def show_issues(self) -> None:
-        selector = IssueSelectionWindow(self, self.config, self.talker, self.series_id, self.issue_number)
-        title = ""
-        for record in self.ct_search_results:
-            if record.id == self.series_id:
-                title = record.name
-                title += " (" + str(record.start_year) + ")"
-                title += " - "
-                break
-
-        selector.setWindowTitle(title + "Select Issue")
-        selector.setModal(True)
-        selector.exec()
-        if selector.result():
-            # we should now have a series ID
-            self.issue_number = selector.issue_number
-            self.issue_id = selector.issue_id
-            self.accept()
-
-    def select_by_id(self) -> None:
-        for r in range(0, self.twList.rowCount()):
-            series_id = self.twList.item(r, 0).data(QtCore.Qt.ItemDataRole.UserRole)
-            if series_id == self.series_id:
-                self.twList.selectRow(r)
-                break
-
-    def perform_query(self, refresh: bool = False) -> None:
-        self.search_thread = SearchThread(
-            self.talker, self.series_name, refresh, self.literal, self.config.identifier_series_match_search_thresh
-        )
-        self.search_thread.searchComplete.connect(self.search_complete)
-        self.search_thread.progressUpdate.connect(self.search_progress_update)
-        self.search_thread.start()
-
-        self.progdialog = QtWidgets.QProgressDialog("Searching Online", "Cancel", 0, 100, self)
-        self.progdialog.setWindowTitle("Online Search")
-        self.progdialog.canceled.connect(self.search_canceled)
-        self.progdialog.setModal(True)
-        self.progdialog.setMinimumDuration(300)
-
-        if refresh or self.search_thread.isRunning():
-            self.progdialog.exec()
-        else:
-            self.progdialog = None
-
-    def search_canceled(self) -> None:
-        if self.progdialog is not None:
-            logger.info("query cancelled")
-            if self.search_thread is not None:
-                self.search_thread.searchComplete.disconnect()
-                self.search_thread.progressUpdate.disconnect()
-            self.progdialog.canceled.disconnect()
-            self.progdialog.reject()
-            QtCore.QTimer.singleShot(200, self.close_me)
-
-    def close_me(self) -> None:
-        self.reject()
-
-    def search_progress_update(self, current: int, total: int) -> None:
-        if self.progdialog is not None:
-            self.progdialog.setMaximum(total)
-            self.progdialog.setValue(current + 1)
-
-    def search_complete(self) -> None:
-        if self.progdialog is not None:
-            self.progdialog.accept()
-            del self.progdialog
-        if self.search_thread is not None and self.search_thread.ct_error:
-            # TODO Currently still opens the window
-            QtWidgets.QMessageBox.critical(
-                self,
-                f"{self.search_thread.error_e.source} {self.search_thread.error_e.code_name} Error",
-                f"{self.search_thread.error_e}",
-            )
-            return
-
-        self.ct_search_results = self.search_thread.ct_search_results if self.search_thread is not None else []
-        # filter the publishers if enabled set
-        if self.use_filter:
-            try:
-                publisher_filter = {s.strip().casefold() for s in self.config.identifier_publisher_filter}
-                # use '' as publisher name if None
-                self.ct_search_results = list(
-                    filter(
-                        lambda d: ("" if d.publisher is None else str(d.publisher).casefold()) not in publisher_filter,
-                        self.ct_search_results,
-                    )
-                )
-            except Exception:
-                logger.exception("bad data error filtering publishers")
-
-        # pre sort the data - so that we can put exact matches first afterwards
-        # compare as str in case extra chars ie. '1976?'
-        # - missing (none) values being converted to 'None' - consistent with prior behaviour in v1.2.3
-        # sort by start_year if set
-        if self.config.identifier_sort_series_by_year:
-            try:
-                self.ct_search_results = sorted(
-                    self.ct_search_results,
-                    key=lambda i: (str(i.start_year), str(i.count_of_issues)),
-                    reverse=True,
-                )
-            except Exception:
-                logger.exception("bad data error sorting results by start_year,count_of_issues")
-        else:
-            try:
-                self.ct_search_results = sorted(
-                    self.ct_search_results, key=lambda i: str(i.count_of_issues), reverse=True
-                )
-            except Exception:
-                logger.exception("bad data error sorting results by count_of_issues")
-
-        # move sanitized matches to the front
-        if self.config.identifier_exact_series_matches_first:
-            try:
-                sanitized = utils.sanitize_title(self.series_name, False).casefold()
-                sanitized_no_articles = utils.sanitize_title(self.series_name, True).casefold()
-
-                deques: list[deque[ComicSeries]] = [deque(), deque(), deque()]
-
-                def categorize(result: ComicSeries) -> int:
-                    # We don't remove anything on this one so that we only get exact matches
-                    if utils.sanitize_title(result.name, True).casefold() == sanitized_no_articles:
-                        return 0
-
-                    # this ensures that 'The Joker' is near the top even if you search 'Joker'
-                    if utils.sanitize_title(result.name, False).casefold() in sanitized:
-                        return 1
-                    return 2
-
-                for comic in self.ct_search_results:
-                    deques[categorize(comic)].append(comic)
-                logger.info("Length: %d, %d, %d", len(deques[0]), len(deques[1]), len(deques[2]))
-                self.ct_search_results = list(itertools.chain.from_iterable(deques))
-            except Exception:
-                logger.exception("bad data error filtering exact/near matches")
-
-        self.update_buttons()
-
-        self.twList.setSortingEnabled(False)
-
-        self.twList.setRowCount(0)
-
-        row = 0
-        for record in self.ct_search_results:
-            self.twList.insertRow(row)
-
-            item_text = record.name
-            item = QtWidgets.QTableWidgetItem(item_text)
-            item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
-            item.setData(QtCore.Qt.ItemDataRole.UserRole, record.id)
-            item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
-            self.twList.setItem(row, 0, item)
-
-            item_text = str(record.start_year)
-            item = QtWidgets.QTableWidgetItem(item_text)
-            item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
-            item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
-            self.twList.setItem(row, 1, item)
-
-            item_text = str(record.count_of_issues)
-            item = QtWidgets.QTableWidgetItem(item_text)
-            item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
-            item.setData(QtCore.Qt.ItemDataRole.DisplayRole, record.count_of_issues)
-            item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
-            self.twList.setItem(row, 2, item)
-
-            if record.publisher is not None:
-                item_text = record.publisher
-                item.setData(QtCore.Qt.ItemDataRole.ToolTipRole, item_text)
-                item = QtWidgets.QTableWidgetItem(item_text)
-                item.setFlags(QtCore.Qt.ItemFlag.ItemIsSelectable | QtCore.Qt.ItemFlag.ItemIsEnabled)
-                self.twList.setItem(row, 3, item)
-
-            row += 1
-
-        self.twList.setSortingEnabled(True)
-        self.twList.selectRow(0)
-        self.twList.resizeColumnsToContents()
-        # Get the width of the issues, year and publisher columns
-        owidth = self.twList.columnWidth(1) + self.twList.columnWidth(2) + self.twList.columnWidth(3)
-        # Get the remaining width after they fill the tableWidget
-        rwidth = self.twList.contentsRect().width() - owidth
-
-        # Default the tableWidget to truncate series names
-        self.twList.setColumnWidth(0, rwidth)
-
-        # Resize row height so the whole series can still be seen
-        self.twList.resizeRowsToContents()
-
-    def showEvent(self, event: QtGui.QShowEvent) -> None:
-        self.perform_query()
-        if not self.ct_search_results:
-            QtCore.QCoreApplication.processEvents()
-            QtWidgets.QMessageBox.information(self, "Search Result", "No matches found!")
-            QtCore.QTimer.singleShot(200, self.close_me)
-
-        elif self.immediate_autoselect:
-            # defer the immediate autoselect so this dialog has time to pop up
-            QtCore.QCoreApplication.processEvents()
-            QtCore.QTimer.singleShot(10, self.do_immediate_autoselect)
-
-    def do_immediate_autoselect(self) -> None:
-        self.immediate_autoselect = False
-        self.auto_select()
-
-    def cell_double_clicked(self, r: int, c: int) -> None:
-        self.show_issues()
-
-    def current_item_changed(self, curr: QtCore.QModelIndex | None, prev: QtCore.QModelIndex | None) -> None:
-        if curr is None:
-            return
-        if prev is not None and prev.row() == curr.row():
-            return
-
-        self.series_id = self.twList.item(curr.row(), 0).data(QtCore.Qt.ItemDataRole.UserRole)
-
-        # list selection was changed, update the info on the series
-        for record in self.ct_search_results:
-            if record.id == self.series_id:
-                if record.description is None:
-                    self.teDetails.setText("")
-                else:
-                    self.teDetails.setText(record.description)
-                self.imageWidget.set_url(record.image_url)
-                break

comictaggerlib/settings.py

@@ -0,0 +1,426 @@
+"""Settings class for ComicTagger app"""
+
+# Copyright 2012-2014 Anthony Beville
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import codecs
+import configparser
+import os
+import platform
+import sys
+import uuid
+
+from . import utils
+
+
+class ComicTaggerSettings:
+    @staticmethod
+    def getSettingsFolder():
+        filename_encoding = sys.getfilesystemencoding()
+        if platform.system() == "Windows":
+            folder = os.path.join(os.environ["APPDATA"], "ComicTagger")
+        else:
+            folder = os.path.join(os.path.expanduser("~"), ".ComicTagger")
+        if folder is not None:
+            folder = folder
+        return folder
+
+    @staticmethod
+    def defaultLibunrarPath():
+        return ComicTaggerSettings.baseDir() + "/libunrar.so"
+
+    @staticmethod
+    def haveOwnUnrarLib():
+        return os.path.exists(ComicTaggerSettings.defaultLibunrarPath())
+
+    @staticmethod
+    def baseDir():
+        if getattr(sys, "frozen", None):
+            return sys._MEIPASS
+        else:
+            return os.path.dirname(os.path.abspath(__file__))
+
+    @staticmethod
+    def getGraphic(filename):
+        graphic_folder = os.path.join(ComicTaggerSettings.baseDir(), "graphics")
+        return os.path.join(graphic_folder, filename)
+
+    @staticmethod
+    def getUIFile(filename):
+        ui_folder = os.path.join(ComicTaggerSettings.baseDir(), "ui")
+        return os.path.join(ui_folder, filename)
+
+    def setDefaultValues(self):
+        # General Settings
+        self.rar_exe_path = ""
+        self.unrar_lib_path = ""
+        self.allow_cbi_in_rar = True
+        self.check_for_new_version = False
+        self.send_usage_stats = False
+
+        # automatic settings
+        self.install_id = uuid.uuid4().hex
+        self.last_selected_save_data_style = 0
+        self.last_selected_load_data_style = 0
+        self.last_opened_folder = ""
+        self.last_main_window_width = 0
+        self.last_main_window_height = 0
+        self.last_main_window_x = 0
+        self.last_main_window_y = 0
+        self.last_form_side_width = -1
+        self.last_list_side_width = -1
+        self.last_filelist_sorted_column = -1
+        self.last_filelist_sorted_order = 0
+
+        # identifier settings
+        self.id_length_delta_thresh = 5
+        self.id_publisher_blacklist = "Panini Comics, Abril, Planeta DeAgostini, Editorial Televisa, Dino Comics"
+
+        # Show/ask dialog flags
+        self.ask_about_cbi_in_rar = True
+        self.show_disclaimer = True
+        self.dont_notify_about_this_version = ""
+        self.ask_about_usage_stats = True
+        self.show_no_unrar_warning = True
+
+        # filename parsing settings
+        self.parse_scan_info = True
+
+        # Comic Vine settings
+        self.use_series_start_as_volume = False
+        self.clear_form_before_populating_from_cv = False
+        self.remove_html_tables = False
+        self.cv_api_key = ""
+        self.auto_imprint = False
+
+        # CBL Tranform settings
+
+        self.assume_lone_credit_is_primary = False
+        self.copy_characters_to_tags = False
+        self.copy_teams_to_tags = False
+        self.copy_locations_to_tags = False
+        self.copy_storyarcs_to_tags = False
+        self.copy_notes_to_comments = False
+        self.copy_weblink_to_comments = False
+        self.apply_cbl_transform_on_cv_import = False
+        self.apply_cbl_transform_on_bulk_operation = False
+
+        # Rename settings
+        self.rename_template = "{publisher}/{series}/{series} #{issue} - {title} ({year})"
+        self.rename_issue_number_padding = 3
+        self.rename_use_smart_string_cleanup = True
+        self.rename_extension_based_on_archive = True
+        self.rename_dir = ""
+        self.rename_move_dir = False
+
+        # Auto-tag stickies
+        self.save_on_low_confidence = False
+        self.dont_use_year_when_identifying = False
+        self.assume_1_if_no_issue_num = False
+        self.ignore_leading_numbers_in_filename = False
+        self.remove_archive_after_successful_match = False
+        self.wait_and_retry_on_rate_limit = False
+
+    def __init__(self):
+
+        self.settings_file = ""
+        self.folder = ""
+        self.setDefaultValues()
+
+        self.config = configparser.RawConfigParser()
+        self.folder = ComicTaggerSettings.getSettingsFolder()
+
+        if not os.path.exists(self.folder):
+            os.makedirs(self.folder)
+
+        self.settings_file = os.path.join(self.folder, "settings")
+
+        # if config file doesn't exist, write one out
+        if not os.path.exists(self.settings_file):
+            self.save()
+        else:
+            self.load()
+
+        # take a crack at finding rar exe, if not set already
+        if self.rar_exe_path == "":
+            if platform.system() == "Windows":
+                # look in some likely places for Windows machines
+                if os.path.exists("C:\Program Files\WinRAR\Rar.exe"):
+                    self.rar_exe_path = "C:\Program Files\WinRAR\Rar.exe"
+                elif os.path.exists("C:\Program Files (x86)\WinRAR\Rar.exe"):
+                    self.rar_exe_path = "C:\Program Files (x86)\WinRAR\Rar.exe"
+            else:
+                # see if it's in the path of unix user
+                if utils.which("rar") is not None:
+                    self.rar_exe_path = utils.which("rar")
+            if self.rar_exe_path != "":
+                self.save()
+        if self.rar_exe_path != "":
+            # make sure rar program is now in the path for the rar class
+            utils.addtopath(os.path.dirname(self.rar_exe_path))
+
+        if self.haveOwnUnrarLib():
+            # We have a 'personal' copy of the unrar lib in the basedir, so
+            # don't search and change the setting
+            # NOTE: a manual edit of the settings file overrides this below
+            os.environ["UNRAR_LIB_PATH"] = self.defaultLibunrarPath()
+
+        elif self.unrar_lib_path == "":
+            # Priority is for unrar lib search is:
+            #    1. explicit setting in settings file
+            #    2. UNRAR_LIB_PATH in environment
+            #    3. check some likely platform specific places
+            if "UNRAR_LIB_PATH" in os.environ:
+                self.unrar_lib_path = os.environ["UNRAR_LIB_PATH"]
+            else:
+                # look in some platform specific places:
+                if platform.system() == "Windows":
+                    # Default location for the RARLab DLL installer
+                    if platform.architecture()[0] == "64bit" and os.path.exists("C:\\Program Files (x86)\\UnrarDLL\\x64\\UnRAR64.dll"):
+                        self.unrar_lib_path = "C:\\Program Files (x86)\\UnrarDLL\\x64\\UnRAR64.dll"
+                    elif platform.architecture()[0] == "32bit" and os.path.exists("C:\\Program Files\\UnrarDLL\\UnRAR.dll"):
+                        self.unrar_lib_path = "C:\\Program Files\\UnrarDLL\\UnRAR.dll"
+                elif platform.system() == "Darwin":
+                    # Look for the brew unrar library
+                    if os.path.exists("/usr/local/lib/libunrar.dylib"):
+                        self.unrar_lib_path = "/usr/local/lib/libunrar.dylib"
+                elif platform.system() == "Linux":
+                    if os.path.exists("/usr/local/lib/libunrar.so"):
+                        self.unrar_lib_path = "/usr/local/lib/libunrar.so"
+                    elif os.path.exists("/usr/lib/libunrar.so"):
+                        self.unrar_lib_path = "/usr/lib/libunrar.so"
+
+            if self.unrar_lib_path != "":
+                self.save()
+
+        if self.unrar_lib_path != "":
+            # This needs to occur before the unrar module is loaded for the first time
+            os.environ["UNRAR_LIB_PATH"] = self.unrar_lib_path
+
+    def reset(self):
+        os.unlink(self.settings_file)
+        self.__init__()
+
+    def load(self):
+        def readline_generator(f):
+            line = f.readline()
+            while line:
+                yield line
+                line = f.readline()
+
+        # self.config.readfp(codecs.open(self.settings_file, "r", "utf8"))
+        self.config.read_file(readline_generator(codecs.open(self.settings_file, "r", "utf8")))
+
+        self.rar_exe_path = self.config.get("settings", "rar_exe_path")
+        if self.config.has_option("settings", "unrar_lib_path"):
+            self.unrar_lib_path = self.config.get("settings", "unrar_lib_path")
+        if self.config.has_option("settings", "check_for_new_version"):
+            self.check_for_new_version = self.config.getboolean("settings", "check_for_new_version")
+        if self.config.has_option("settings", "send_usage_stats"):
+            self.send_usage_stats = self.config.getboolean("settings", "send_usage_stats")
+
+        if self.config.has_option("auto", "install_id"):
+            self.install_id = self.config.get("auto", "install_id")
+        if self.config.has_option("auto", "last_selected_load_data_style"):
+            self.last_selected_load_data_style = self.config.getint("auto", "last_selected_load_data_style")
+        if self.config.has_option("auto", "last_selected_save_data_style"):
+            self.last_selected_save_data_style = self.config.getint("auto", "last_selected_save_data_style")
+        if self.config.has_option("auto", "last_opened_folder"):
+            self.last_opened_folder = self.config.get("auto", "last_opened_folder")
+        if self.config.has_option("auto", "last_main_window_width"):
+            self.last_main_window_width = self.config.getint("auto", "last_main_window_width")
+        if self.config.has_option("auto", "last_main_window_height"):
+            self.last_main_window_height = self.config.getint("auto", "last_main_window_height")
+        if self.config.has_option("auto", "last_main_window_x"):
+            self.last_main_window_x = self.config.getint("auto", "last_main_window_x")
+        if self.config.has_option("auto", "last_main_window_y"):
+            self.last_main_window_y = self.config.getint("auto", "last_main_window_y")
+        if self.config.has_option("auto", "last_form_side_width"):
+            self.last_form_side_width = self.config.getint("auto", "last_form_side_width")
+        if self.config.has_option("auto", "last_list_side_width"):
+            self.last_list_side_width = self.config.getint("auto", "last_list_side_width")
+        if self.config.has_option("auto", "last_filelist_sorted_column"):
+            self.last_filelist_sorted_column = self.config.getint("auto", "last_filelist_sorted_column")
+        if self.config.has_option("auto", "last_filelist_sorted_order"):
+            self.last_filelist_sorted_order = self.config.getint("auto", "last_filelist_sorted_order")
+
+        if self.config.has_option("identifier", "id_length_delta_thresh"):
+            self.id_length_delta_thresh = self.config.getint("identifier", "id_length_delta_thresh")
+        if self.config.has_option("identifier", "id_publisher_blacklist"):
+            self.id_publisher_blacklist = self.config.get("identifier", "id_publisher_blacklist")
+
+        if self.config.has_option("filenameparser", "parse_scan_info"):
+            self.parse_scan_info = self.config.getboolean("filenameparser", "parse_scan_info")
+
+        if self.config.has_option("dialogflags", "ask_about_cbi_in_rar"):
+            self.ask_about_cbi_in_rar = self.config.getboolean("dialogflags", "ask_about_cbi_in_rar")
+        if self.config.has_option("dialogflags", "show_disclaimer"):
+            self.show_disclaimer = self.config.getboolean("dialogflags", "show_disclaimer")
+        if self.config.has_option("dialogflags", "dont_notify_about_this_version"):
+            self.dont_notify_about_this_version = self.config.get("dialogflags", "dont_notify_about_this_version")
+        if self.config.has_option("dialogflags", "ask_about_usage_stats"):
+            self.ask_about_usage_stats = self.config.getboolean("dialogflags", "ask_about_usage_stats")
+        if self.config.has_option("dialogflags", "show_no_unrar_warning"):
+            self.show_no_unrar_warning = self.config.getboolean("dialogflags", "show_no_unrar_warning")
+
+        if self.config.has_option("comicvine", "use_series_start_as_volume"):
+            self.use_series_start_as_volume = self.config.getboolean("comicvine", "use_series_start_as_volume")
+        if self.config.has_option("comicvine", "clear_form_before_populating_from_cv"):
+            self.clear_form_before_populating_from_cv = self.config.getboolean("comicvine", "clear_form_before_populating_from_cv")
+        if self.config.has_option("comicvine", "remove_html_tables"):
+            self.remove_html_tables = self.config.getboolean("comicvine", "remove_html_tables")
+        if self.config.has_option("comicvine", "cv_api_key"):
+            self.cv_api_key = self.config.get("comicvine", "cv_api_key")
+
+        if self.config.has_option("cbl_transform", "assume_lone_credit_is_primary"):
+            self.assume_lone_credit_is_primary = self.config.getboolean("cbl_transform", "assume_lone_credit_is_primary")
+        if self.config.has_option("cbl_transform", "copy_characters_to_tags"):
+            self.copy_characters_to_tags = self.config.getboolean("cbl_transform", "copy_characters_to_tags")
+        if self.config.has_option("cbl_transform", "copy_teams_to_tags"):
+            self.copy_teams_to_tags = self.config.getboolean("cbl_transform", "copy_teams_to_tags")
+        if self.config.has_option("cbl_transform", "copy_locations_to_tags"):
+            self.copy_locations_to_tags = self.config.getboolean("cbl_transform", "copy_locations_to_tags")
+        if self.config.has_option("cbl_transform", "copy_notes_to_comments"):
+            self.copy_notes_to_comments = self.config.getboolean("cbl_transform", "copy_notes_to_comments")
+        if self.config.has_option("cbl_transform", "copy_storyarcs_to_tags"):
+            self.copy_storyarcs_to_tags = self.config.getboolean("cbl_transform", "copy_storyarcs_to_tags")
+        if self.config.has_option("cbl_transform", "copy_weblink_to_comments"):
+            self.copy_weblink_to_comments = self.config.getboolean("cbl_transform", "copy_weblink_to_comments")
+        if self.config.has_option("cbl_transform", "apply_cbl_transform_on_cv_import"):
+            self.apply_cbl_transform_on_cv_import = self.config.getboolean("cbl_transform", "apply_cbl_transform_on_cv_import")
+        if self.config.has_option("cbl_transform", "apply_cbl_transform_on_bulk_operation"):
+            self.apply_cbl_transform_on_bulk_operation = self.config.getboolean("cbl_transform", "apply_cbl_transform_on_bulk_operation")
+
+        if self.config.has_option("rename", "rename_template"):
+            self.rename_template = self.config.get("rename", "rename_template")
+        if self.config.has_option("rename", "rename_issue_number_padding"):
+            self.rename_issue_number_padding = self.config.getint("rename", "rename_issue_number_padding")
+        if self.config.has_option("rename", "rename_use_smart_string_cleanup"):
+            self.rename_use_smart_string_cleanup = self.config.getboolean("rename", "rename_use_smart_string_cleanup")
+        if self.config.has_option("rename", "rename_extension_based_on_archive"):
+            self.rename_extension_based_on_archive = self.config.getboolean("rename", "rename_extension_based_on_archive")
+        if self.config.has_option("rename", "rename_dir"):
+            self.rename_dir = self.config.get("rename", "rename_dir")
+        if self.config.has_option("rename", "rename_move_dir"):
+            self.rename_move_dir = self.config.getboolean("rename", "rename_move_dir")
+
+        if self.config.has_option("autotag", "save_on_low_confidence"):
+            self.save_on_low_confidence = self.config.getboolean("autotag", "save_on_low_confidence")
+        if self.config.has_option("autotag", "dont_use_year_when_identifying"):
+            self.dont_use_year_when_identifying = self.config.getboolean("autotag", "dont_use_year_when_identifying")
+        if self.config.has_option("autotag", "assume_1_if_no_issue_num"):
+            self.assume_1_if_no_issue_num = self.config.getboolean("autotag", "assume_1_if_no_issue_num")
+        if self.config.has_option("autotag", "ignore_leading_numbers_in_filename"):
+            self.ignore_leading_numbers_in_filename = self.config.getboolean("autotag", "ignore_leading_numbers_in_filename")
+        if self.config.has_option("autotag", "remove_archive_after_successful_match"):
+            self.remove_archive_after_successful_match = self.config.getboolean("autotag", "remove_archive_after_successful_match")
+        if self.config.has_option("autotag", "wait_and_retry_on_rate_limit"):
+            self.wait_and_retry_on_rate_limit = self.config.getboolean("autotag", "wait_and_retry_on_rate_limit")
+        if self.config.has_option("autotag", "auto_imprint"):
+            self.auto_imprint = self.config.getboolean("autotag", "auto_imprint")
+
+    def save(self):
+
+        if not self.config.has_section("settings"):
+            self.config.add_section("settings")
+
+        self.config.set("settings", "check_for_new_version", self.check_for_new_version)
+        self.config.set("settings", "rar_exe_path", self.rar_exe_path)
+        self.config.set("settings", "unrar_lib_path", self.unrar_lib_path)
+        self.config.set("settings", "send_usage_stats", self.send_usage_stats)
+
+        if not self.config.has_section("auto"):
+            self.config.add_section("auto")
+
+        self.config.set("auto", "install_id", self.install_id)
+        self.config.set("auto", "last_selected_load_data_style", self.last_selected_load_data_style)
+        self.config.set("auto", "last_selected_save_data_style", self.last_selected_save_data_style)
+        self.config.set("auto", "last_opened_folder", self.last_opened_folder)
+        self.config.set("auto", "last_main_window_width", self.last_main_window_width)
+        self.config.set("auto", "last_main_window_height", self.last_main_window_height)
+        self.config.set("auto", "last_main_window_x", self.last_main_window_x)
+        self.config.set("auto", "last_main_window_y", self.last_main_window_y)
+        self.config.set("auto", "last_form_side_width", self.last_form_side_width)
+        self.config.set("auto", "last_list_side_width", self.last_list_side_width)
+        self.config.set("auto", "last_filelist_sorted_column", self.last_filelist_sorted_column)
+        self.config.set("auto", "last_filelist_sorted_order", self.last_filelist_sorted_order)
+
+        if not self.config.has_section("identifier"):
+            self.config.add_section("identifier")
+
+        self.config.set("identifier", "id_length_delta_thresh", self.id_length_delta_thresh)
+        self.config.set("identifier", "id_publisher_blacklist", self.id_publisher_blacklist)
+
+        if not self.config.has_section("dialogflags"):
+            self.config.add_section("dialogflags")
+
+        self.config.set("dialogflags", "ask_about_cbi_in_rar", self.ask_about_cbi_in_rar)
+        self.config.set("dialogflags", "show_disclaimer", self.show_disclaimer)
+        self.config.set("dialogflags", "dont_notify_about_this_version", self.dont_notify_about_this_version)
+        self.config.set("dialogflags", "ask_about_usage_stats", self.ask_about_usage_stats)
+        self.config.set("dialogflags", "show_no_unrar_warning", self.show_no_unrar_warning)
+
+        if not self.config.has_section("filenameparser"):
+            self.config.add_section("filenameparser")
+
+        self.config.set("filenameparser", "parse_scan_info", self.parse_scan_info)
+
+        if not self.config.has_section("comicvine"):
+            self.config.add_section("comicvine")
+
+        self.config.set("comicvine", "use_series_start_as_volume", self.use_series_start_as_volume)
+        self.config.set("comicvine", "clear_form_before_populating_from_cv", self.clear_form_before_populating_from_cv)
+        self.config.set("comicvine", "remove_html_tables", self.remove_html_tables)
+        self.config.set("comicvine", "cv_api_key", self.cv_api_key)
+
+        if not self.config.has_section("cbl_transform"):
+            self.config.add_section("cbl_transform")
+
+        self.config.set("cbl_transform", "assume_lone_credit_is_primary", self.assume_lone_credit_is_primary)
+        self.config.set("cbl_transform", "copy_characters_to_tags", self.copy_characters_to_tags)
+        self.config.set("cbl_transform", "copy_teams_to_tags", self.copy_teams_to_tags)
+        self.config.set("cbl_transform", "copy_locations_to_tags", self.copy_locations_to_tags)
+        self.config.set("cbl_transform", "copy_storyarcs_to_tags", self.copy_storyarcs_to_tags)
+        self.config.set("cbl_transform", "copy_notes_to_comments", self.copy_notes_to_comments)
+        self.config.set("cbl_transform", "copy_weblink_to_comments", self.copy_weblink_to_comments)
+        self.config.set("cbl_transform", "apply_cbl_transform_on_cv_import", self.apply_cbl_transform_on_cv_import)
+        self.config.set("cbl_transform", "apply_cbl_transform_on_bulk_operation", self.apply_cbl_transform_on_bulk_operation)
+
+        if not self.config.has_section("rename"):
+            self.config.add_section("rename")
+
+        self.config.set("rename", "rename_template", self.rename_template)
+        self.config.set("rename", "rename_issue_number_padding", self.rename_issue_number_padding)
+        self.config.set("rename", "rename_use_smart_string_cleanup", self.rename_use_smart_string_cleanup)
+        self.config.set("rename", "rename_extension_based_on_archive", self.rename_extension_based_on_archive)
+        self.config.set("rename", "rename_dir", self.rename_dir)
+        self.config.set("rename", "rename_move_dir", self.rename_move_dir)
+
+        if not self.config.has_section("autotag"):
+            self.config.add_section("autotag")
+        self.config.set("autotag", "save_on_low_confidence", self.save_on_low_confidence)
+        self.config.set("autotag", "dont_use_year_when_identifying", self.dont_use_year_when_identifying)
+        self.config.set("autotag", "assume_1_if_no_issue_num", self.assume_1_if_no_issue_num)
+        self.config.set("autotag", "ignore_leading_numbers_in_filename", self.ignore_leading_numbers_in_filename)
+        self.config.set("autotag", "remove_archive_after_successful_match", self.remove_archive_after_successful_match)
+        self.config.set("autotag", "wait_and_retry_on_rate_limit", self.wait_and_retry_on_rate_limit)
+        self.config.set("autotag", "auto_imprint", self.auto_imprint)
+
+        with codecs.open(self.settings_file, "wb", "utf8") as configfile:
+            self.config.write(configfile)
+
+
+# make sure the basedir is cached, in case we're on Windows running a
+# script from frozen binary
+ComicTaggerSettings.baseDir()

comictaggerlib/settingswindow.py

@@ -1,523 +1,398 @@
 """A PyQT4 dialog to enter app settings"""
-#
-# Copyright 2012-2014 ComicTagger Authors
-#
+
+# Copyright 2012-2014 Anthony Beville
+
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from __future__ import annotations
 
-import html
-import logging
 import os
-import pathlib
 import platform
-from typing import Any
+import sys
 
-import settngs
 from PyQt5 import QtCore, QtGui, QtWidgets, uic
 
-import comictaggerlib.ui.talkeruigenerator
-from comicapi import utils
-from comicapi.genericmetadata import md_test
-from comictaggerlib import ctsettings
-from comictaggerlib.ctversion import version
-from comictaggerlib.filerenamer import FileRenamer, Replacement, Replacements
-from comictaggerlib.imagefetcher import ImageFetcher
-from comictaggerlib.ui import ui_path
-from comictalker.comiccacher import ComicCacher
-from comictalker.comictalker import ComicTalker
-
-logger = logging.getLogger(__name__)
+from . import utils
+from .comicvinecacher import ComicVineCacher
+from .comicvinetalker import ComicVineTalker
+from .filerenamer import FileRenamer
+from .genericmetadata import GenericMetadata
+from .imagefetcher import ImageFetcher
+from .settings import ComicTaggerSettings
 
 windowsRarHelp = """
-                <html><head/><body><p>To write to CBR/RAR archives,
-                you will need to have the tools from
-                <span style=" text-decoration: underline; color:#0000ff;">
-                <a href="http://www.win-rar.com/download.html">WINRar</a></span>
-                installed. (ComicTagger only uses the command-line rar tool.)
-                </p></body></html>
+                 <html><head/><body><p>To write to CBR/RAR archives,
+                 you will need to have the tools from
+                 <span style=" text-decoration: underline; color:#0000ff;">
+                 <a href="http://www.win-rar.com/download.html">WINRar</a></span>
+                 installed. (ComicTagger only uses the command-line rar tool,
+                 which is free to use.)</p></body></html>
                 """
 
 linuxRarHelp = """
-                <html><head/><body><p>To write to CBR/RAR archives,
-                you will need to have the shareware rar tool from RARLab installed.
-                Your package manager should have rar (e.g. "apt-get install rar"). If not, download it
-                <span style=" text-decoration: underline; color:#0000ff;">
-                <a href="https://www.rarlab.com/download.htm">here</a></span>,
-                and install in your path. </p></body></html>
-                """
+               <html><head/><body><p>To write to CBR/RAR archives,
+               you will need to have the shareware rar tool from RARLab installed.
+               Your package manager should have rar (e.g. "apt-get install rar"). If not, download it
+               <span style=" text-decoration: underline; color:#0000ff;">
+               <a href="https://www.rarlab.com/download.htm">here</a></span>,
+               and install in your path. </p></body></html>
+               """
 
 macRarHelp = """
-                <html><head/><body><p>To write to CBR/RAR archives,
-                you will need the rar tool.  The easiest way to get this is
-                to install <span style=" text-decoration: underline; color:#0000ff;">
-                <a href="https://brew.sh/">homebrew</a></span>.
-                </p>Once homebrew is installed, run: <b>brew install caskroom/cask/rar</b></body></html>
+                 <html><head/><body><p>To write to CBR/RAR archives,
+                 you will need the rar tool.  The easiest way to get this is
+                 to install <span style=" text-decoration: underline; color:#0000ff;">
+                 <a href="https://brew.sh/">homebrew</a></span>.
+                 </p>Once homebrew is installed, run: <b>brew install caskroom/cask/rar</b></body></html>
                 """
 
+windowsUnrarHelp = """
+                 <html><head/><body><p>To read CBR/RAR archives,
+                 you will need to have the unrar DLL from
+                 <span style=" text-decoration: underline; color:#0000ff;">
+                 <a href="https://www.rarlab.com/rar_add.htm">
+                 RARLab</a></span> installed. </p></body></html>
+                """
 
-template_tooltip = """
-The template for the new filename. Uses python format strings https://docs.python.org/3/library/string.html#format-string-syntax
-Accepts the following variables:
-{is_empty}         (boolean)
-{tag_origin}       (string)
-{series}           (string)
-{issue}            (string)
-{title}            (string)
-{publisher}        (string)
-{month}            (integer)
-{year}             (integer)
-{day}              (integer)
-{issue_count}      (integer)
-{volume}           (integer)
-{genre}            (string)
-{language}         (string)
-{comments}         (string)
-{volume_count}     (integer)
-{critical_rating}  (float)
-{country}          (string)
-{alternate_series} (string)
-{alternate_number} (string)
-{alternate_count}  (integer)
-{imprint}          (string)
-{notes}            (string)
-{web_link}         (string)
-{format}           (string)
-{manga}            (string)
-{black_and_white}  (boolean)
-{page_count}       (integer)
-{maturity_rating}  (string)
-{story_arc}        (string)
-{series_group}     (string)
-{scan_info}        (string)
-{characters}       (string)
-{teams}            (string)
-{locations}        (string)
-{credits}          (list of dict({'role': string, 'person': string, 'primary': boolean}))
-{writer}           (string)
-{penciller}        (string)
-{inker}            (string)
-{colorist}         (string)
-{letterer}         (string)
-{cover artist}     (string)
-{editor}           (string)
-{tags}             (list of str)
-{pages}            (list of dict({'Image': string(int), 'Type': string, 'Bookmark': string, 'DoublePage': boolean}))
+linuxUnrarHelp = """
+               <html><head/><body><p>To read CBR/RAR archives,
+               you will need to have the unrar library from RARLab installed.
+               Look <span style=" text-decoration: underline; color:#0000ff;">
+               <a href="https://github.com/beville/libunrar-binaries/releases">here</a></span>
+               for pre-compiled binaries, or <span style=" text-decoration: underline; color:#0000ff;">
+               <a href="https://www.rarlab.com/rar_add.htm">here</a></span>
+               for the UnRAR source (which is easy to compile on Linux). </p></body></html>
+               """
 
-CoMet-only items:
-{price}            (float)
-{is_version_of}    (string)
-{rights}           (string)
-{identifier}       (string)
-{last_mark}        (string)
-{cover_image}      (string)
-
-Examples:
-
-{series} {issue} ({year})
-Spider-Geddon 1 (2018)
-
-{series} #{issue} - {title}
-Spider-Geddon #1 - New Players; Check In
-"""
+macUnrarHelp = """
+                 <html><head/><body><p>To read CBR/RAR archives,
+                 you will need the unrar library.  The easiest way to get this is
+                 to install <span style=" text-decoration: underline; color:#0000ff;">
+                 <a href="https://brew.sh/homebrew">homebrew</a></span>.
+                 </p>Once homebrew is installed, run: <b>brew install unrar</b></body></html>
+                """
 
 
 class SettingsWindow(QtWidgets.QDialog):
-    def __init__(
-        self, parent: QtWidgets.QWidget, config: settngs.Config[settngs.Namespace], talkers: dict[str, ComicTalker]
-    ) -> None:
-        super().__init__(parent)
+    def __init__(self, parent, settings):
+        super(SettingsWindow, self).__init__(parent)
 
-        uic.loadUi(ui_path / "settingswindow.ui", self)
+        uic.loadUi(ComicTaggerSettings.getUIFile("settingswindow.ui"), self)
 
-        self.setWindowFlags(
-            QtCore.Qt.WindowType(self.windowFlags() & ~QtCore.Qt.WindowType.WindowContextHelpButtonHint)
-        )
+        self.setWindowFlags(self.windowFlags() & ~QtCore.Qt.WindowContextHelpButtonHint)
 
-        self.config = config
-        self.talkers = talkers
+        self.settings = settings
         self.name = "Settings"
 
+        self.priorUnrarLibPath = self.settings.unrar_lib_path
+
+        if self.settings.haveOwnUnrarLib():
+            # We have our own unrarlib, so no need for this GUI
+            self.grpBoxUnrar.hide()
+
         if platform.system() == "Windows":
             self.lblRarHelp.setText(windowsRarHelp)
+            self.lblUnrarHelp.setText(windowsUnrarHelp)
 
         elif platform.system() == "Linux":
             self.lblRarHelp.setText(linuxRarHelp)
+            self.lblUnrarHelp.setText(linuxUnrarHelp)
 
         elif platform.system() == "Darwin":
+            # Mac file dialog hides "/usr" and others, so allow user to type
+            self.leUnrarLibPath.setReadOnly(False)
             self.leRarExePath.setReadOnly(False)
 
             self.lblRarHelp.setText(macRarHelp)
+            self.lblUnrarHelp.setText(macUnrarHelp)
             self.name = "Preferences"
 
         self.setWindowTitle("ComicTagger " + self.name)
-        self.lblDefaultSettings.setText("Revert to default " + self.name.casefold())
+        self.lblDefaultSettings.setText("Revert to default " + self.name.lower())
         self.btnResetSettings.setText("Default " + self.name)
 
-        nmit_tip = """<html>The <b>Name Match Ratio Threshold: Auto-Identify</b> is for eliminating automatic
-                search matches that are too long compared to your series name search. The lower
+        nldtTip = """<html>The <b>Default Name Length Match Tolerance</b> is for eliminating automatic
+                search matches that are too long compared to your series name search. The higher
                 it is, the more likely to have a good match, but each search will take longer and
-                use more bandwidth. Too high, and only the very closest matches will be explored.</html>"""
-        nmst_tip = """<html>The <b>Name Match Ratio Threshold: Search</b> is for reducing the total
-                number of results that are returned from a search. The lower it is, the more pages will
-                be returned (max 5 pages or 500 results)</html>"""
+                use more bandwidth. Too low, and only the very closest lexical matches will be
+                explored.</html>"""
 
-        self.sbNameMatchIdentifyThresh.setToolTip(nmit_tip)
-        self.sbNameMatchSearchThresh.setToolTip(nmst_tip)
+        self.leNameLengthDeltaThresh.setToolTip(nldtTip)
 
-        pbl_tip = """<html>
-            The <b>Publisher Filter</b> is for eliminating automatic matches to certain publishers
+        pblTip = """<html>
+            The <b>Publisher Blacklist</b> is for eliminating automatic matches to certain publishers
             that you know are incorrect. Useful for avoiding international re-prints with same
             covers or series names. Enter publisher names separated by commas.
             </html>"""
-        self.tePublisherFilter.setToolTip(pbl_tip)
+        self.tePublisherBlacklist.setToolTip(pblTip)
 
         validator = QtGui.QIntValidator(1, 4, self)
         self.leIssueNumPadding.setValidator(validator)
 
-        self.leRenameTemplate.setToolTip(f"<pre>{html.escape(template_tooltip)}</pre>")
-        self.rename_error: Exception | None = None
+        validator = QtGui.QIntValidator(0, 99, self)
+        self.leNameLengthDeltaThresh.setValidator(validator)
 
-        self.sources: dict = comictaggerlib.ui.talkeruigenerator.generate_source_option_tabs(
-            self.tComicTalkers, self.config, self.talkers
-        )
-        self.connect_signals()
-        self.settings_to_form()
-        self.rename_test()
-        self.dir_test()
+        self.settingsToForm()
 
-        # Set General as start tab
-        self.tabWidget.setCurrentIndex(0)
+        self.btnBrowseRar.clicked.connect(self.selectRar)
+        self.btnBrowseUnrar.clicked.connect(self.selectUnrar)
+        self.btnClearCache.clicked.connect(self.clearCache)
+        self.btnResetSettings.clicked.connect(self.resetSettings)
+        self.btnTestKey.clicked.connect(self.testAPIKey)
+        self.btnTemplateHelp.clicked.connect(self.showTemplateHelp)
 
-    def connect_signals(self) -> None:
-        self.btnBrowseRar.clicked.connect(self.select_rar)
-        self.btnClearCache.clicked.connect(self.clear_cache)
-        self.btnResetSettings.clicked.connect(self.reset_settings)
-        self.btnTemplateHelp.clicked.connect(self.show_template_help)
-        self.cbxMoveFiles.clicked.connect(self.dir_test)
-        self.leDirectory.textEdited.connect(self.dir_test)
-        self.cbxComplicatedParser.clicked.connect(self.switch_parser)
+    def configRenamer(self):
+        md = GenericMetadata()
+        md.isEmpty = False
+        md.tagOrigin = "testing"
 
-        self.btnAddLiteralReplacement.clicked.connect(self.addLiteralReplacement)
-        self.btnAddValueReplacement.clicked.connect(self.addValueReplacement)
-        self.btnRemoveLiteralReplacement.clicked.connect(self.removeLiteralReplacement)
-        self.btnRemoveValueReplacement.clicked.connect(self.removeValueReplacement)
+        md.series = "series name"
+        md.issue = "1"
+        md.title = "issue title"
+        md.publisher = "lordwelch"
+        md.month = 4
+        md.year = 1998
+        md.day = 4
+        md.issueCount = 1
+        md.volume = 256
+        md.genre = "test"
+        md.language = "en"  # 2 letter iso code
+        md.comments = "This is definitly not something you want to read."  # use same way as Summary in CIX
 
-        self.leRenameTemplate.textEdited.connect(self.rename_test)
-        self.cbxMoveFiles.clicked.connect(self.rename_test)
-        self.cbxRenameStrict.clicked.connect(self.rename_test)
-        self.cbxSmartCleanup.clicked.connect(self.rename_test)
-        self.cbxChangeExtension.clicked.connect(self.rename_test)
-        self.leIssueNumPadding.textEdited.connect(self.rename_test)
-        self.twLiteralReplacements.cellChanged.connect(self.rename_test)
-        self.twValueReplacements.cellChanged.connect(self.rename_test)
+        md.volumeCount = 4096
+        md.criticalRating = "Worst Comic Ever"
+        md.country = "US"
 
-    def disconnect_signals(self) -> None:
-        self.btnAddLiteralReplacement.clicked.disconnect()
-        self.btnAddValueReplacement.clicked.disconnect()
-        self.btnBrowseRar.clicked.disconnect()
-        self.btnClearCache.clicked.disconnect()
-        self.btnRemoveLiteralReplacement.clicked.disconnect()
-        self.btnRemoveValueReplacement.clicked.disconnect()
-        self.btnResetSettings.clicked.disconnect()
-        self.btnTemplateHelp.clicked.disconnect()
-        self.cbxChangeExtension.clicked.disconnect()
-        self.cbxComplicatedParser.clicked.disconnect()
-        self.cbxMoveFiles.clicked.disconnect()
-        self.cbxRenameStrict.clicked.disconnect()
-        self.cbxSmartCleanup.clicked.disconnect()
-        self.leDirectory.textEdited.disconnect()
-        self.leIssueNumPadding.textEdited.disconnect()
-        self.leRenameTemplate.textEdited.disconnect()
-        self.twLiteralReplacements.cellChanged.disconnect()
-        self.twValueReplacements.cellChanged.disconnect()
+        md.alternateSeries = "None"
+        md.alternateNumber = 4.4
+        md.alternateCount = 4444
+        md.imprint = "Welch Publishing"
+        md.notes = "This doesn't actually exist"
+        md.webLink = "https://example.com/series name/1"
+        md.format = "Box Set"
+        md.manga = "Yes"
+        md.blackAndWhite = False
+        md.pageCount = 4
+        md.maturityRating = "Everyone"
 
-    def addLiteralReplacement(self) -> None:
-        self.insertRow(self.twLiteralReplacements, self.twLiteralReplacements.rowCount(), Replacement("", "", False))
+        md.storyArc = "None of your buisness"
+        md.seriesGroup = "Advertures of buisness"
+        md.scanInfo = "(lordwelch)"
 
-    def addValueReplacement(self) -> None:
-        self.insertRow(self.twValueReplacements, self.twValueReplacements.rowCount(), Replacement("", "", False))
+        md.characters = "lordwelch, Welch"
+        md.teams = "None"
+        md.locations = "Earth, 444 B.C."
 
-    def removeLiteralReplacement(self) -> None:
-        if self.twLiteralReplacements.currentRow() >= 0:
-            self.twLiteralReplacements.removeRow(self.twLiteralReplacements.currentRow())
+        md.credits = [dict({"role": "Everything", "person": "lordwelch", "primary": True})]
+        md.tags = ["testing", "not testing", "fake"]
+        md.pages = [dict({"Image": "0", "Type": "Front Cover"}), dict({"Image": "1", "Type": "Story"})]
 
-    def removeValueReplacement(self) -> None:
-        if self.twValueReplacements.currentRow() >= 0:
-            self.twValueReplacements.removeRow(self.twValueReplacements.currentRow())
+        # Some CoMet-only items
+        md.price = 0.00
+        md.isVersionOf = "SERIES #1"
+        md.rights = "None"
+        md.identifier = "LW4444-Comic"
+        md.lastMark = "0"
+        md.coverImage = "https://example.com/series name/1/cover"
 
-    def insertRow(self, table: QtWidgets.QTableWidget, row: int, replacement: Replacement) -> None:
-        find, replace, strict_only = replacement
-        table.insertRow(row)
-        table.setItem(row, 0, QtWidgets.QTableWidgetItem(find))
-        table.setItem(row, 1, QtWidgets.QTableWidgetItem(replace))
-        tmp = QtWidgets.QTableWidgetItem()
-        if strict_only:
-            tmp.setCheckState(QtCore.Qt.Checked)
-        else:
-            tmp.setCheckState(QtCore.Qt.Unchecked)
-        table.setItem(row, 2, tmp)
+        self.renamer = FileRenamer(md)
+        self.renamer.setTemplate(str(self.leRenameTemplate.text()))
+        self.renamer.setIssueZeroPadding(self.settings.rename_issue_number_padding)
+        self.renamer.setSmartCleanup(self.settings.rename_use_smart_string_cleanup)
 
-    def rename_test(self, *args: Any, **kwargs: Any) -> None:
-        self._rename_test(self.leRenameTemplate.text())
+    def settingsToForm(self):
 
-    def dir_test(self) -> None:
-        self.lblDir.setText(
-            str(pathlib.Path(self.leDirectory.text().strip()).resolve()) if self.cbxMoveFiles.isChecked() else ""
-        )
-
-    def _rename_test(self, template: str) -> None:
-        fr = FileRenamer(
-            md_test,
-            platform="universal" if self.cbxRenameStrict.isChecked() else "auto",
-            replacements=self.get_replacements(),
-        )
-        fr.move = self.cbxMoveFiles.isChecked()
-        fr.set_template(template)
-        fr.set_issue_zero_padding(int(self.leIssueNumPadding.text()))
-        fr.set_smart_cleanup(self.cbxSmartCleanup.isChecked())
-        try:
-            self.lblRenameTest.setText(fr.determine_name(".cbz"))
-            self.rename_error = None
-        except Exception as e:
-            self.rename_error = e
-            self.lblRenameTest.setText(str(e))
-
-    def switch_parser(self) -> None:
-        complicated = self.cbxComplicatedParser.isChecked()
-
-        self.cbxRemoveC2C.setEnabled(complicated)
-        self.cbxRemoveFCBD.setEnabled(complicated)
-        self.cbxRemovePublisher.setEnabled(complicated)
-
-    def settings_to_form(self) -> None:
-        self.disconnect_signals()
         # Copy values from settings to form
-        if "archiver" in self.config[1] and "rar" in self.config[1]["archiver"].v:
-            self.leRarExePath.setText(getattr(self.config[0], self.config[1]["archiver"].v["rar"].internal_name))
-        else:
-            self.leRarExePath.setEnabled(False)
-        self.sbNameMatchIdentifyThresh.setValue(self.config[0].identifier_series_match_identify_thresh)
-        self.sbNameMatchSearchThresh.setValue(self.config[0].identifier_series_match_search_thresh)
-        self.tePublisherFilter.setPlainText("\n".join(self.config[0].identifier_publisher_filter))
+        self.leRarExePath.setText(self.settings.rar_exe_path)
+        self.leUnrarLibPath.setText(self.settings.unrar_lib_path)
+        self.leNameLengthDeltaThresh.setText(str(self.settings.id_length_delta_thresh))
+        self.tePublisherBlacklist.setPlainText(self.settings.id_publisher_blacklist)
 
-        self.cbxCheckForNewVersion.setChecked(self.config[0].general_check_for_new_version)
+        if self.settings.check_for_new_version:
+            self.cbxCheckForNewVersion.setCheckState(QtCore.Qt.Checked)
 
-        self.cbxComplicatedParser.setChecked(self.config[0].filename_complicated_parser)
-        self.cbxRemoveC2C.setChecked(self.config[0].filename_remove_c2c)
-        self.cbxRemoveFCBD.setChecked(self.config[0].filename_remove_fcbd)
-        self.cbxRemovePublisher.setChecked(self.config[0].filename_remove_publisher)
-        self.switch_parser()
+        if self.settings.parse_scan_info:
+            self.cbxParseScanInfo.setCheckState(QtCore.Qt.Checked)
 
-        self.cbxClearFormBeforePopulating.setChecked(self.config[0].identifier_clear_form_before_populating)
-        self.cbxUseFilter.setChecked(self.config[0].identifier_always_use_publisher_filter)
-        self.cbxSortByYear.setChecked(self.config[0].identifier_sort_series_by_year)
-        self.cbxExactMatches.setChecked(self.config[0].identifier_exact_series_matches_first)
+        if self.settings.use_series_start_as_volume:
+            self.cbxUseSeriesStartAsVolume.setCheckState(QtCore.Qt.Checked)
+        if self.settings.clear_form_before_populating_from_cv:
+            self.cbxClearFormBeforePopulating.setCheckState(QtCore.Qt.Checked)
+        if self.settings.remove_html_tables:
+            self.cbxRemoveHtmlTables.setCheckState(QtCore.Qt.Checked)
+        self.leKey.setText(str(self.settings.cv_api_key))
 
-        self.cbxAssumeLoneCreditIsPrimary.setChecked(self.config[0].cbl_assume_lone_credit_is_primary)
-        self.cbxCopyCharactersToTags.setChecked(self.config[0].cbl_copy_characters_to_tags)
-        self.cbxCopyTeamsToTags.setChecked(self.config[0].cbl_copy_teams_to_tags)
-        self.cbxCopyLocationsToTags.setChecked(self.config[0].cbl_copy_locations_to_tags)
-        self.cbxCopyStoryArcsToTags.setChecked(self.config[0].cbl_copy_storyarcs_to_tags)
-        self.cbxCopyNotesToComments.setChecked(self.config[0].cbl_copy_notes_to_comments)
-        self.cbxCopyWebLinkToComments.setChecked(self.config[0].cbl_copy_weblink_to_comments)
-        self.cbxApplyCBLTransformOnCVIMport.setChecked(self.config[0].cbl_apply_transform_on_import)
-        self.cbxApplyCBLTransformOnBatchOperation.setChecked(self.config[0].cbl_apply_transform_on_bulk_operation)
+        if self.settings.assume_lone_credit_is_primary:
+            self.cbxAssumeLoneCreditIsPrimary.setCheckState(QtCore.Qt.Checked)
+        if self.settings.copy_characters_to_tags:
+            self.cbxCopyCharactersToTags.setCheckState(QtCore.Qt.Checked)
+        if self.settings.copy_teams_to_tags:
+            self.cbxCopyTeamsToTags.setCheckState(QtCore.Qt.Checked)
+        if self.settings.copy_locations_to_tags:
+            self.cbxCopyLocationsToTags.setCheckState(QtCore.Qt.Checked)
+        if self.settings.copy_storyarcs_to_tags:
+            self.cbxCopyStoryArcsToTags.setCheckState(QtCore.Qt.Checked)
+        if self.settings.copy_notes_to_comments:
+            self.cbxCopyNotesToComments.setCheckState(QtCore.Qt.Checked)
+        if self.settings.copy_weblink_to_comments:
+            self.cbxCopyWebLinkToComments.setCheckState(QtCore.Qt.Checked)
+        if self.settings.apply_cbl_transform_on_cv_import:
+            self.cbxApplyCBLTransformOnCVIMport.setCheckState(QtCore.Qt.Checked)
+        if self.settings.apply_cbl_transform_on_bulk_operation:
+            self.cbxApplyCBLTransformOnBatchOperation.setCheckState(QtCore.Qt.Checked)
 
-        self.leRenameTemplate.setText(self.config[0].rename_template)
-        self.leIssueNumPadding.setText(str(self.config[0].rename_issue_number_padding))
-        self.cbxSmartCleanup.setChecked(self.config[0].rename_use_smart_string_cleanup)
-        self.cbxChangeExtension.setChecked(self.config[0].rename_set_extension_based_on_archive)
-        self.cbxMoveFiles.setChecked(self.config[0].rename_move_to_dir)
-        self.leDirectory.setText(self.config[0].rename_dir)
-        self.cbxRenameStrict.setChecked(self.config[0].rename_strict)
+        self.leRenameTemplate.setText(self.settings.rename_template)
+        self.leIssueNumPadding.setText(str(self.settings.rename_issue_number_padding))
+        if self.settings.rename_use_smart_string_cleanup:
+            self.cbxSmartCleanup.setCheckState(QtCore.Qt.Checked)
+        if self.settings.rename_extension_based_on_archive:
+            self.cbxChangeExtension.setCheckState(QtCore.Qt.Checked)
+        if self.settings.rename_move_dir:
+            self.cbxMoveFiles.setCheckState(QtCore.Qt.Checked)
+        self.leDirectory.setText(self.settings.rename_dir)
 
-        for table, replacments in zip(
-            (self.twLiteralReplacements, self.twValueReplacements), self.config[0].rename_replacements
-        ):
-            table.clearContents()
-            for i in reversed(range(table.rowCount())):
-                table.removeRow(i)
-            for row, replacement in enumerate(replacments):
-                self.insertRow(table, row, replacement)
+    def accept(self):
 
-        # Set talker values
-        comictaggerlib.ui.talkeruigenerator.settings_to_talker_form(self.sources, self.config)
+        self.configRenamer()
 
-        self.connect_signals()
-
-    def get_replacements(self) -> Replacements:
-        literal_replacements = []
-        value_replacements = []
-        for row in range(self.twLiteralReplacements.rowCount()):
-            if self.twLiteralReplacements.item(row, 0).text():
-                literal_replacements.append(
-                    Replacement(
-                        self.twLiteralReplacements.item(row, 0).text(),
-                        self.twLiteralReplacements.item(row, 1).text(),
-                        self.twLiteralReplacements.item(row, 2).checkState() == QtCore.Qt.Checked,
-                    )
-                )
-        for row in range(self.twValueReplacements.rowCount()):
-            if self.twValueReplacements.item(row, 0).text():
-                value_replacements.append(
-                    Replacement(
-                        self.twValueReplacements.item(row, 0).text(),
-                        self.twValueReplacements.item(row, 1).text(),
-                        self.twValueReplacements.item(row, 2).checkState() == QtCore.Qt.Checked,
-                    )
-                )
-        return Replacements(literal_replacements, value_replacements)
-
-    def accept(self) -> None:
-        self.rename_test()
-        if self.rename_error is not None:
-            if isinstance(self.rename_error, ValueError):
-                logger.exception("Invalid format string: %s", self.config[0].rename_template)
-                QtWidgets.QMessageBox.critical(
-                    self,
-                    "Invalid format string!",
-                    "Your rename template is invalid!"
-                    f"<br/><br/>{self.rename_error}<br/><br/>"
-                    "Please consult the template help in the "
-                    "settings and the documentation on the format at "
-                    "<a href='https://docs.python.org/3/library/string.html#format-string-syntax'>"
-                    "https://docs.python.org/3/library/string.html#format-string-syntax</a>",
-                )
-                return
-            else:
-                logger.exception(
-                    "Formatter failure: %s metadata: %s", self.config[0].rename_template, self.renamer.metadata
-                )
-                QtWidgets.QMessageBox.critical(
-                    self,
-                    "The formatter had an issue!",
-                    "The formatter has experienced an unexpected error!"
-                    f"<br/><br/>{type(self.rename_error).__name__}: {self.rename_error}<br/><br/>"
-                    "Please open an issue at "
-                    "<a href='https://github.com/comictagger/comictagger'>"
-                    "https://github.com/comictagger/comictagger</a>",
-                )
+        try:
+            new_name = self.renamer.determineName("test.cbz")
+        except Exception as e:
+            QtWidgets.QMessageBox.critical(
+                self,
+                "Invalid format string!",
+                "Your rename template is invalid!"
+                "<br/><br/>{}<br/><br/>"
+                "Please consult the template help in the "
+                "settings and the documentation on the format at "
+                "<a href='https://docs.python.org/3/library/string.html#format-string-syntax'>"
+                "https://docs.python.org/3/library/string.html#format-string-syntax</a>".format(e),
+            )
+            return
 
         # Copy values from form to settings and save
-        if "archiver" in self.config[1] and "rar" in self.config[1]["archiver"].v:
-            setattr(self.config[0], self.config[1]["archiver"].v["rar"].internal_name, str(self.leRarExePath.text()))
+        self.settings.rar_exe_path = str(self.leRarExePath.text())
 
-            # make sure rar program is now in the path for the rar class
-            if self.config[0].archiver_rar:
-                utils.add_to_path(os.path.dirname(str(self.leRarExePath.text())))
+        # Don't accept the form info if we have our own unrar lib
+        if not self.settings.haveOwnUnrarLib():
+            self.settings.unrar_lib_path = str(self.leUnrarLibPath.text())
+
+        # make sure rar program is now in the path for the rar class
+        if self.settings.rar_exe_path:
+            utils.addtopath(os.path.dirname(self.settings.rar_exe_path))
+
+        if self.settings.unrar_lib_path:
+            os.environ["UNRAR_LIB_PATH"] = self.settings.unrar_lib_path
+            # This doesn't do anything... we need to restart!
+
+        if not str(self.leNameLengthDeltaThresh.text()).isdigit():
+            self.leNameLengthDeltaThresh.setText("0")
 
         if not str(self.leIssueNumPadding.text()).isdigit():
             self.leIssueNumPadding.setText("0")
 
-        self.config[0].general_check_for_new_version = self.cbxCheckForNewVersion.isChecked()
+        self.settings.check_for_new_version = self.cbxCheckForNewVersion.isChecked()
 
-        self.config[0].identifier_series_match_identify_thresh = self.sbNameMatchIdentifyThresh.value()
-        self.config[0].identifier_series_match_search_thresh = self.sbNameMatchSearchThresh.value()
-        self.config[0].identifier_publisher_filter = [
-            x.strip() for x in str(self.tePublisherFilter.toPlainText()).splitlines() if x.strip()
-        ]
+        self.settings.id_length_delta_thresh = int(self.leNameLengthDeltaThresh.text())
+        self.settings.id_publisher_blacklist = str(self.tePublisherBlacklist.toPlainText())
 
-        self.config[0].filename_complicated_parser = self.cbxComplicatedParser.isChecked()
-        self.config[0].filename_remove_c2c = self.cbxRemoveC2C.isChecked()
-        self.config[0].filename_remove_fcbd = self.cbxRemoveFCBD.isChecked()
-        self.config[0].filename_remove_publisher = self.cbxRemovePublisher.isChecked()
+        self.settings.parse_scan_info = self.cbxParseScanInfo.isChecked()
 
-        self.config[0].identifier_clear_form_before_populating = self.cbxClearFormBeforePopulating.isChecked()
-        self.config[0].identifier_always_use_publisher_filter = self.cbxUseFilter.isChecked()
-        self.config[0].identifier_sort_series_by_year = self.cbxSortByYear.isChecked()
-        self.config[0].identifier_exact_series_matches_first = self.cbxExactMatches.isChecked()
+        self.settings.use_series_start_as_volume = self.cbxUseSeriesStartAsVolume.isChecked()
+        self.settings.clear_form_before_populating_from_cv = self.cbxClearFormBeforePopulating.isChecked()
+        self.settings.remove_html_tables = self.cbxRemoveHtmlTables.isChecked()
+        self.settings.cv_api_key = str(self.leKey.text())
+        ComicVineTalker.api_key = self.settings.cv_api_key.strip()
+        self.settings.assume_lone_credit_is_primary = self.cbxAssumeLoneCreditIsPrimary.isChecked()
+        self.settings.copy_characters_to_tags = self.cbxCopyCharactersToTags.isChecked()
+        self.settings.copy_teams_to_tags = self.cbxCopyTeamsToTags.isChecked()
+        self.settings.copy_locations_to_tags = self.cbxCopyLocationsToTags.isChecked()
+        self.settings.copy_storyarcs_to_tags = self.cbxCopyStoryArcsToTags.isChecked()
+        self.settings.copy_notes_to_comments = self.cbxCopyNotesToComments.isChecked()
+        self.settings.copy_weblink_to_comments = self.cbxCopyWebLinkToComments.isChecked()
+        self.settings.apply_cbl_transform_on_cv_import = self.cbxApplyCBLTransformOnCVIMport.isChecked()
+        self.settings.apply_cbl_transform_on_bulk_operation = self.cbxApplyCBLTransformOnBatchOperation.isChecked()
 
-        self.config[0].cbl_assume_lone_credit_is_primary = self.cbxAssumeLoneCreditIsPrimary.isChecked()
-        self.config[0].cbl_copy_characters_to_tags = self.cbxCopyCharactersToTags.isChecked()
-        self.config[0].cbl_copy_teams_to_tags = self.cbxCopyTeamsToTags.isChecked()
-        self.config[0].cbl_copy_locations_to_tags = self.cbxCopyLocationsToTags.isChecked()
-        self.config[0].cbl_copy_storyarcs_to_tags = self.cbxCopyStoryArcsToTags.isChecked()
-        self.config[0].cbl_copy_notes_to_comments = self.cbxCopyNotesToComments.isChecked()
-        self.config[0].cbl_copy_weblink_to_comments = self.cbxCopyWebLinkToComments.isChecked()
-        self.config[0].cbl_apply_transform_on_import = self.cbxApplyCBLTransformOnCVIMport.isChecked()
-        self.config[0].cbl_apply_transform_on_bulk_operation = self.cbxApplyCBLTransformOnBatchOperation.isChecked()
+        self.settings.rename_template = str(self.leRenameTemplate.text())
+        self.settings.rename_issue_number_padding = int(self.leIssueNumPadding.text())
+        self.settings.rename_use_smart_string_cleanup = self.cbxSmartCleanup.isChecked()
+        self.settings.rename_extension_based_on_archive = self.cbxChangeExtension.isChecked()
+        self.settings.rename_move_dir = self.cbxMoveFiles.isChecked()
+        self.settings.rename_dir = self.leDirectory.text()
 
-        self.config[0].rename_template = str(self.leRenameTemplate.text())
-        self.config[0].rename_issue_number_padding = int(self.leIssueNumPadding.text())
-        self.config[0].rename_use_smart_string_cleanup = self.cbxSmartCleanup.isChecked()
-        self.config[0].rename_set_extension_based_on_archive = self.cbxChangeExtension.isChecked()
-        self.config[0].rename_move_to_dir = self.cbxMoveFiles.isChecked()
-        self.config[0].rename_dir = self.leDirectory.text()
-
-        self.config[0].rename_strict = self.cbxRenameStrict.isChecked()
-        self.config[0].rename_replacements = self.get_replacements()
-
-        # Read settings from talker tabs
-        comictaggerlib.ui.talkeruigenerator.form_settings_to_config(self.sources, self.config)
-
-        self.update_talkers_config()
-
-        settngs.save_file(self.config, self.config[0].runtime_config.user_config_dir / "settings.json")
-        self.parent().config = self.config
+        self.settings.save()
         QtWidgets.QDialog.accept(self)
 
-    def update_talkers_config(self) -> None:
-        ctsettings.talkers = self.talkers
-        self.config = ctsettings.plugin.validate_talker_settings(self.config)
-        del ctsettings.talkers
+        if self.priorUnrarLibPath != self.settings.unrar_lib_path:
+            QtWidgets.QMessageBox.information(self, "UnRar Library Change", "ComicTagger will need to be restarted for changes to take effect.")
 
-    def select_rar(self) -> None:
-        self.select_file(self.leRarExePath, "RAR")
+    def selectRar(self):
+        self.selectFile(self.leRarExePath, "RAR")
 
-    def clear_cache(self) -> None:
-        ImageFetcher(self.config[0].runtime_config.user_cache_dir).clear_cache()
-        ComicCacher(self.config[0].runtime_config.user_cache_dir, version).clear_cache()
+    def selectUnrar(self):
+        self.selectFile(self.leUnrarLibPath, "UnRAR")
+
+    def clearCache(self):
+        ImageFetcher().clearCache()
+        ComicVineCacher().clearCache()
         QtWidgets.QMessageBox.information(self, self.name, "Cache has been cleared.")
 
-    def reset_settings(self) -> None:
-        self.config = settngs.get_namespace(settngs.defaults(self.config[1]))
-        self.settings_to_form()
+    def testAPIKey(self):
+        if ComicVineTalker().testKey(str(self.leKey.text()).strip()):
+            QtWidgets.QMessageBox.information(self, "API Key Test", "Key is valid!")
+        else:
+            QtWidgets.QMessageBox.warning(self, "API Key Test", "Key is NOT valid.")
+
+    def resetSettings(self):
+        self.settings.reset()
+        self.settingsToForm()
         QtWidgets.QMessageBox.information(self, self.name, self.name + " have been returned to default values.")
 
-    def select_file(self, control: QtWidgets.QLineEdit, name: str) -> None:
+    def selectFile(self, control, name):
+
         dialog = QtWidgets.QFileDialog(self)
-        dialog.setFileMode(QtWidgets.QFileDialog.FileMode.ExistingFile)
+        dialog.setFileMode(QtWidgets.QFileDialog.ExistingFile)
 
         if platform.system() == "Windows":
             if name == "RAR":
-                flt = "Rar Program (Rar.exe)"
+                filter = self.tr("Rar Program (Rar.exe)")
             else:
-                flt = "Libraries (*.dll)"
-            dialog.setNameFilter(flt)
+                filter = self.tr("Libraries (*.dll)")
+            dialog.setNameFilter(filter)
         else:
-            dialog.setFilter(QtCore.QDir.Filter.Files)
+            # QtCore.QDir.Executable | QtCore.QDir.Files)
+            dialog.setFilter(QtCore.QDir.Files)
+            pass
 
         dialog.setDirectory(os.path.dirname(str(control.text())))
         if name == "RAR":
-            dialog.setWindowTitle(f"Find {name} program")
+            dialog.setWindowTitle("Find " + name + " program")
         else:
-            dialog.setWindowTitle(f"Find {name} library")
+            dialog.setWindowTitle("Find " + name + " library")
 
-        if dialog.exec():
-            file_list = dialog.selectedFiles()
-            control.setText(str(file_list[0]))
+        if dialog.exec_():
+            fileList = dialog.selectedFiles()
+            control.setText(str(fileList[0]))
 
-    def show_rename_tab(self) -> None:
+    def showRenameTab(self):
         self.tabWidget.setCurrentIndex(5)
 
-    def show_template_help(self) -> None:
-        template_help_win = TemplateHelpWindow(self)
-        template_help_win.setModal(False)
-        template_help_win.show()
+    def showTemplateHelp(self):
+        TemplateHelpWin = TemplateHelpWindow(self)
+        TemplateHelpWin.setModal(False)
+        TemplateHelpWin.show()
 
 
 class TemplateHelpWindow(QtWidgets.QDialog):
-    def __init__(self, parent: QtWidgets.QWidget) -> None:
-        super().__init__(parent)
+    def __init__(self, parent):
+        super(TemplateHelpWindow, self).__init__(parent)
 
-        uic.loadUi(ui_path / "TemplateHelp.ui", self)
+        uic.loadUi(ComicTaggerSettings.getUIFile("TemplateHelp.ui"), self)

comictaggerlib/ui/TemplateHelp.ui

@@ -27,94 +27,62 @@
     <number>2</number>
    </property>
    <item>
-    <widget class="QTextBrowser" name="textEdit">
-     <property name="readOnly">
-      <bool>true</bool>
-     </property>
+    <widget class="QTextBrowser" name="textBrowser">
      <property name="html">
       <string>&lt;html&gt;
-     &lt;head&gt;
-     &lt;style&gt;
-table {
-  font-family: arial, sans-serif;
-  border-collapse: collapse;
-  width: 100%;
-}
+	&lt;head/&gt;
+	&lt;body&gt;
+		&lt;h1 style=&quot;text-align: center&quot;&gt;Template help&lt;/h1&gt;
+		&lt;p&gt;The template uses Python format strings, in the simplest use it replaces the field (e.g. {issue}) with the value for that particular comic (e.g. 1) for advanced formatting please reference the
 
-td, th {
-  border: 1px solid #dddddd;
-  text-align: left;
-  padding: 8px;
-}
+			&lt;a href=&quot;https://docs.python.org/3/library/string.html#format-string-syntax&quot;&gt;Python 3 documentation&lt;/a&gt;&lt;/p&gt;
+		&lt;pre&gt;Accepts the following variables:
+{isEmpty}&#009;&#009;(boolean)
+{tagOrigin}&#009;&#009;(string)
+{series}&#009;&#009;(string)
+{issue}&#009;&#009;(string)
+{title}&#009;&#009;(string)
+{publisher}&#009;&#009;(string)
+{month}&#009;&#009;(integer)
+{year}&#009;&#009;(integer)
+{day}&#009;&#009;(integer)
+{issueCount}&#009;(integer)
+{volume}&#009;&#009;(integer)
+{genre}&#009;&#009;(string)
+{language}&#009;&#009;(string)
+{comments}&#009;&#009;(string)
+{volumeCount}&#009;(integer)
+{criticalRating}&#009;(string)
+{country}&#009;&#009;(string)
+{alternateSeries}&#009;(string)
+{alternateNumber}&#009;(string)
+{alternateCount}&#009;(integer)
+{imprint}&#009;&#009;(string)
+{notes}&#009;&#009;(string)
+{webLink}&#009;&#009;(string)
+{format}&#009;&#009;(string)
+{manga}&#009;&#009;(string)
+{blackAndWhite}&#009;(boolean)
+{pageCount}&#009;&#009;(integer)
+{maturityRating}&#009;(string)
+{storyArc}&#009;&#009;(string)
+{seriesGroup}&#009;(string)
+{scanInfo}&#009;&#009;(string)
+{characters}&#009;(string)
+{teams}&#009;&#009;(string)
+{locations}&#009;&#009;(string)
+{credits}&#009;&#009;(list of dict({&apos;role&apos;: &apos;str&apos;, &apos;person&apos;: &apos;str&apos;, &apos;primary&apos;: boolean}))
+{tags}&#009;&#009;(list of str)
+{pages}&#009;&#009;(list of dict({&apos;Image&apos;: &apos;str(int)&apos;, &apos;Type&apos;: &apos;str&apos;}))
 
-tr:nth-child(even) {
-  background-color: #dddddd;
-}
-&lt;/style&gt;
-     &lt;/head&gt;
-     &lt;body&gt;
-          &lt;h1 style="text-align: center"&gt;Template help&lt;/h1&gt;
-          &lt;p&gt;The template uses Python format strings, in the simplest use it replaces the field (e.g. {issue}) with the value for that particular comic (e.g. 1) for advanced formatting please reference the
+CoMet-only items:
+{price}&#009;&#009;(float)
+{isVersionOf}&#009;(string)
+{rights}&#009;&#009;(string)
+{identifier}&#009;(string)
+{lastMark}&#009;&#009;(string)
+{coverImage}&#009;(string)
 
-               &lt;a href="https://docs.python.org/3/library/string.html#format-string-syntax"&gt;Python 3 documentation&lt;/a&gt;&lt;/p&gt;
-          Accepts the following variables:
-&lt;table&gt;
-     &lt;tr&gt;
-          &lt;th&gt;Tag name&lt;/th&gt;
-          &lt;th&gt;Type&lt;/th&gt;
-     &lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{is_empty}&lt;/td&gt;&lt;td&gt;boolean&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{tag_origin}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{series}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{issue}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{title}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{publisher}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{month}&lt;/td&gt;&lt;td&gt;integer&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{year}&lt;/td&gt;&lt;td&gt;integer&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{day}&lt;/td&gt;&lt;td&gt;integer&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{issue_count}&lt;/td&gt;&lt;td&gt;integer&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{volume}&lt;/td&gt;&lt;td&gt;integer&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{genre}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{language}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{comments}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{volume_count}&lt;/td&gt;&lt;td&gt;integer&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{critical_rating}&lt;/td&gt;&lt;td&gt;float&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{country}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{alternate_series}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{alternate_number}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{alternate_count}&lt;/td&gt;&lt;td&gt;integer&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{imprint}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{notes}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{web_link}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{format}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{manga}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{black_and_white}&lt;/td&gt;&lt;td&gt;boolean&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{page_count}&lt;/td&gt;&lt;td&gt;integer&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{maturity_rating}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{story_arc}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{series_group}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{scan_info}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{characters}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{teams}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{locations}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{credits}&lt;/td&gt;&lt;td&gt;list of dict({&apos;role&apos;: string, &apos;person&apos;: string, &apos;primary&apos;: boolean})&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{writer}&lt;/td&gt;&lt;td&gt;(string)&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{penciller}&lt;/td&gt;&lt;td&gt;(string)&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{inker}&lt;/td&gt;&lt;td&gt;(string)&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{colorist}&lt;/td&gt;&lt;td&gt;(string)&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{letterer}&lt;/td&gt;&lt;td&gt;(string)&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{cover artist}&lt;/td&gt;&lt;td&gt;(string)&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{editor}&lt;/td&gt;&lt;td&gt;(string)&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{tags}&lt;/td&gt;&lt;td&gt;list of str&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{pages}&lt;/td&gt;&lt;td&gt;list of dict({&apos;Image&apos;: string(int), &apos;Type&apos;: string, &apos;Bookmark&apos;: string, &apos;DoublePage&apos;: boolean})&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{price}&lt;/td&gt;&lt;td&gt;float&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{is_version_of}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{rights}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{identifier}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{last_mark}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-     &lt;tr&gt;&lt;td&gt;{cover_image}&lt;/td&gt;&lt;td&gt;string&lt;/td&gt;&lt;/tr&gt;
-&lt;/table&gt;
-&lt;pre&gt;
 Examples:
 
 {series} {issue} ({year})
@@ -122,12 +90,9 @@ Spider-Geddon 1 (2018)
 
 {series} #{issue} - {title}
 Spider-Geddon #1 - New Players; Check In
-
 &lt;/pre&gt;
-     &lt;/body&gt;
-&lt;/html&gt;</string></property>
-     <property name="textInteractionFlags">
-      <set>Qt::TextBrowserInteraction</set>
+	&lt;/body&gt;
+&lt;/html&gt;</string>
      </property>
      <property name="openExternalLinks">
       <bool>true</bool>

comictaggerlib/ui/__init__.py

@@ -1,5 +0,0 @@
-from __future__ import annotations
-
-import pathlib
-
-ui_path = pathlib.Path(__file__).parent

comictaggerlib/ui/applicationlogwindow.ui

@@ -1,77 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>Dialog</class>
- <widget class="QDialog" name="Dialog">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>400</width>
-    <height>300</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Log Window</string>
-  </property>
-  <layout class="QVBoxLayout" name="verticalLayout">
-   <item>
-    <widget class="QTextEdit" name="textEdit">
-     <property name="readOnly">
-      <bool>true</bool>
-     </property>
-     <property name="acceptRichText">
-      <bool>false</bool>
-     </property>
-     <property name="textInteractionFlags">
-      <set>Qt::LinksAccessibleByKeyboard|Qt::LinksAccessibleByMouse|Qt::TextBrowserInteraction|Qt::TextSelectableByKeyboard|Qt::TextSelectableByMouse</set>
-     </property>
-    </widget>
-   </item>
-   <item>
-    <widget class="QDialogButtonBox" name="buttonBox">
-     <property name="orientation">
-      <enum>Qt::Horizontal</enum>
-     </property>
-     <property name="standardButtons">
-      <set>QDialogButtonBox::Close</set>
-     </property>
-    </widget>
-   </item>
-  </layout>
- </widget>
- <resources/>
- <connections>
-  <connection>
-   <sender>buttonBox</sender>
-   <signal>accepted()</signal>
-   <receiver>Dialog</receiver>
-   <slot>accept()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>248</x>
-     <y>254</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>157</x>
-     <y>274</y>
-    </hint>
-   </hints>
-  </connection>
-  <connection>
-   <sender>buttonBox</sender>
-   <signal>rejected()</signal>
-   <receiver>Dialog</receiver>
-   <slot>reject()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>316</x>
-     <y>260</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>286</x>
-     <y>274</y>
-    </hint>
-   </hints>
-  </connection>
- </connections>
-</ui>

comictaggerlib/ui/autotagprogresswindow.ui

@@ -21,7 +21,7 @@
   </property>
   <layout class="QGridLayout" name="gridLayout">
    <item row="0" column="1">
-    <widget class="QWidget" name="archiveCoverContainer" native="true">
+    <widget class="QWidget" name="archiveCoverContainer">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
        <horstretch>0</horstretch>
@@ -43,7 +43,7 @@
     </widget>
    </item>
    <item row="0" column="4">
-    <widget class="QWidget" name="testCoverContainer" native="true">
+    <widget class="QWidget" name="testCoverContainer">
      <property name="minimumSize">
       <size>
        <width>110</width>

comictaggerlib/ui/autotagstartwindow.ui

@@ -10,7 +10,7 @@
     <x>0</x>
     <y>0</y>
     <width>519</width>
-    <height>440</height>
+    <height>378</height>
    </rect>
   </property>
   <property name="sizePolicy">
@@ -44,17 +44,7 @@
    </item>
    <item row="1" column="0">
     <layout class="QGridLayout" name="gridLayout">
-     <item row="6" column="0">
-      <widget class="QCheckBox" name="cbxAutoImprint">
-       <property name="toolTip">
-        <string>Checks the publisher against a list of imprints.</string>
-       </property>
-       <property name="text">
-        <string>Auto Imprint</string>
-       </property>
-      </widget>
-     </item>
-     <item row="9" column="0">
+     <item row="7" column="0">
       <widget class="QCheckBox" name="cbxSpecifySearchString">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
@@ -67,19 +57,6 @@
        </property>
       </widget>
      </item>
-     <item row="4" column="0">
-      <widget class="QCheckBox" name="cbxIgnoreLeadingDigitsInFilename">
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-       <property name="text">
-        <string>Ignore leading (sequence) numbers in filename</string>
-       </property>
-      </widget>
-     </item>
      <item row="0" column="0">
       <widget class="QCheckBox" name="cbxSaveOnLowConfidence">
        <property name="sizePolicy">
@@ -93,31 +70,8 @@
        </property>
       </widget>
      </item>
-     <item row="10" column="0">
-      <widget class="QLineEdit" name="leSearchString">
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-      </widget>
-     </item>
-     <item row="11" column="0">
-      <widget class="QLabel" name="label_3">
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-       <property name="text">
-        <string>Adjust Name Match Ratio Threshold: Auto-Identify</string>
-       </property>
-      </widget>
-     </item>
-     <item row="8" column="0">
-      <widget class="QCheckBox" name="cbxSplitWords">
+     <item row="4" column="0">
+      <widget class="QCheckBox" name="cbxIgnoreLeadingDigitsInFilename">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
          <horstretch>0</horstretch>
@@ -125,43 +79,7 @@
         </sizepolicy>
        </property>
        <property name="text">
-        <string>Split words in filenames (e.g. 'judgedredd' to 'judge dredd') (Experimental)</string>
-       </property>
-      </widget>
-     </item>
-     <item row="1" column="0">
-      <widget class="QCheckBox" name="cbxDontUseYear">
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-       <property name="text">
-        <string>Don't use publication year in identification process</string>
-       </property>
-      </widget>
-     </item>
-     <item row="2" column="0">
-      <widget class="QCheckBox" name="cbxAssumeIssueOne">
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-       <property name="text">
-        <string>If no issue number, assume &quot;1&quot;</string>
-       </property>
-      </widget>
-     </item>
-     <item row="7" column="0">
-      <widget class="QCheckBox" name="cbxRemoveMetadata">
-       <property name="toolTip">
-        <string>Removes existing metadata before applying retrieved metadata</string>
-       </property>
-       <property name="text">
-        <string>Overwrite metadata</string>
+        <string>Ignore leading (sequence) numbers in filename</string>
        </property>
       </widget>
      </item>
@@ -185,22 +103,78 @@
        </property>
       </widget>
      </item>
-     <item row="12" column="0">
-      <widget class="QSpinBox" name="sbNameMatchSearchThresh">
+     <item row="1" column="0">
+      <widget class="QCheckBox" name="cbxDontUseYear">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="text">
+        <string>Don't use publication year in indentification process</string>
+       </property>
+      </widget>
+     </item>
+     <item row="2" column="0">
+      <widget class="QCheckBox" name="cbxAssumeIssueOne">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="text">
+        <string>If no issue number, assume &quot;1&quot;</string>
+       </property>
+      </widget>
+     </item>
+     <item row="6" column="0">
+      <widget class="QCheckBox" name="cbxAutoImprint">
+       <property name="toolTip">
+        <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Checks the publisher against a list of imprints.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+       </property>
+       <property name="text">
+        <string>Auto Imprint</string>
+       </property>
+      </widget>
+     </item>
+     <item row="10" column="0">
+      <widget class="QLineEdit" name="leNameLengthMatchTolerance">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
        <property name="maximumSize">
         <size>
-         <width>60</width>
+         <width>50</width>
          <height>16777215</height>
         </size>
        </property>
-       <property name="suffix">
-        <string>%</string>
+      </widget>
+     </item>
+     <item row="8" column="0">
+      <widget class="QLineEdit" name="leSearchString">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
        </property>
-       <property name="minimum">
-        <number>1</number>
+      </widget>
+     </item>
+     <item row="9" column="0">
+      <widget class="QLabel" name="label_3">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
        </property>
-       <property name="maximum">
-        <number>100</number>
+       <property name="text">
+        <string>Adjust Name Length Match Tolerance:</string>
        </property>
       </widget>
      </item>

comictaggerlib/ui/coverimagewidget.ui

@@ -14,24 +14,15 @@
    <string>Form</string>
   </property>
   <layout class="QGridLayout" name="gridLayout">
-   <property name="leftMargin">
-    <number>0</number>
-   </property>
-   <property name="topMargin">
-    <number>0</number>
-   </property>
-   <property name="rightMargin">
-    <number>0</number>
-   </property>
-   <property name="bottomMargin">
-    <number>0</number>
-   </property>
    <property name="horizontalSpacing">
     <number>0</number>
    </property>
    <property name="verticalSpacing">
     <number>4</number>
    </property>
+   <property name="margin">
+    <number>0</number>
+   </property>
    <item row="1" column="0">
     <layout class="QHBoxLayout" name="horizontalLayout">
      <property name="spacing">

comictaggerlib/ui/exportwindow.ui

@@ -10,7 +10,7 @@
     <x>0</x>
     <y>0</y>
     <width>533</width>
-    <height>231</height>
+    <height>202</height>
    </rect>
   </property>
   <property name="sizePolicy">

comictaggerlib/ui/fileselectionlist.ui

@@ -28,12 +28,12 @@
      <property name="textElideMode">
       <enum>Qt::ElideMiddle</enum>
      </property>
-     <attribute name="horizontalHeaderMinimumSectionSize">
-      <number>36</number>
-     </attribute>
      <attribute name="horizontalHeaderDefaultSectionSize">
       <number>61</number>
      </attribute>
+     <attribute name="horizontalHeaderMinimumSectionSize">
+      <number>36</number>
+     </attribute>
      <attribute name="horizontalHeaderStretchLastSection">
       <bool>false</bool>
      </attribute>
@@ -45,7 +45,7 @@
        <string>File Name</string>
       </property>
       <property name="textAlignment">
-       <set>AlignCenter</set>
+       <set>AlignHCenter|AlignVCenter|AlignCenter</set>
       </property>
      </column>
      <column>
@@ -56,7 +56,7 @@
        <string>Has ComicRack Tags</string>
       </property>
       <property name="textAlignment">
-       <set>AlignCenter</set>
+       <set>AlignHCenter|AlignVCenter|AlignCenter</set>
       </property>
      </column>
      <column>
@@ -67,7 +67,7 @@
        <string>Has ComicBookLover Tags</string>
       </property>
       <property name="textAlignment">
-       <set>AlignCenter</set>
+       <set>AlignHCenter|AlignVCenter|AlignCenter</set>
       </property>
      </column>
      <column>
@@ -78,7 +78,7 @@
        <string>Archive Type</string>
       </property>
       <property name="textAlignment">
-       <set>AlignCenter</set>
+       <set>AlignHCenter|AlignVCenter|AlignCenter</set>
       </property>
      </column>
      <column>
@@ -89,7 +89,7 @@
        <string>Read-Only</string>
       </property>
       <property name="textAlignment">
-       <set>AlignCenter</set>
+       <set>AlignHCenter|AlignVCenter|AlignCenter</set>
       </property>
      </column>
      <column>
@@ -100,7 +100,7 @@
        <string>File Location</string>
       </property>
       <property name="textAlignment">
-       <set>AlignCenter</set>
+       <set>AlignHCenter|AlignVCenter|AlignCenter</set>
       </property>
      </column>
     </widget>

comictaggerlib/ui/issueselectionwindow.ui

@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>872</width>
-    <height>670</height>
+    <height>550</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -74,6 +74,9 @@
            <property name="text">
             <string>Title</string>
            </property>
+           <property name="textAlignment">
+            <set>AlignHCenter|AlignVCenter|AlignCenter</set>
+           </property>
           </column>
          </widget>
          <widget class="QTextEdit" name="teDescription">
@@ -90,78 +93,20 @@
         </widget>
        </item>
        <item>
-        <layout class="QVBoxLayout" name="verticalLayout_2">
-         <item>
-          <widget class="QWidget" name="coverImageContainer" native="true">
-           <property name="minimumSize">
-            <size>
-             <width>300</width>
-             <height>450</height>
-            </size>
-           </property>
-           <property name="maximumSize">
-            <size>
-             <width>300</width>
-             <height>450</height>
-            </size>
-           </property>
-          </widget>
-         </item>
-         <item>
-          <widget class="Line" name="line">
-           <property name="minimumSize">
-            <size>
-             <width>0</width>
-             <height>0</height>
-            </size>
-           </property>
-           <property name="lineWidth">
-            <number>2</number>
-           </property>
-           <property name="midLineWidth">
-            <number>1</number>
-           </property>
-           <property name="orientation">
-            <enum>Qt::Horizontal</enum>
-           </property>
-          </widget>
-         </item>
-         <item>
-          <widget class="QLabel" name="lblIssuesSourceName">
-           <property name="maximumSize">
-            <size>
-             <width>300</width>
-             <height>16777215</height>
-            </size>
-           </property>
-           <property name="text">
-            <string>Data Source:</string>
-           </property>
-           <property name="alignment">
-            <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
-           </property>
-           <property name="openExternalLinks">
-            <bool>true</bool>
-           </property>
-          </widget>
-         </item>
-         <item>
-          <widget class="QWidget" name="imageIssuesSourceLogo" native="true">
-           <property name="minimumSize">
-            <size>
-             <width>300</width>
-             <height>100</height>
-            </size>
-           </property>
-           <property name="maximumSize">
-            <size>
-             <width>300</width>
-             <height>16777215</height>
-            </size>
-           </property>
-          </widget>
-         </item>
-        </layout>
+        <widget class="QWidget" name="coverImageContainer" native="true">
+         <property name="minimumSize">
+          <size>
+           <width>300</width>
+           <height>450</height>
+          </size>
+         </property>
+         <property name="maximumSize">
+          <size>
+           <width>300</width>
+           <height>450</height>
+          </size>
+         </property>
+        </widget>
        </item>
       </layout>
      </item>