Bump version to v2.3.0

Some projects use different system and arch names in their assets.
Sometimes due to convention or differeing tools and systems. For
example, on macOS 13.6, Python will return the system as `Darwin`.
However, some release assets will be named `macOS` or `macos`. Similarly
`arm64` and `aarch64` are used interchangeably.

This patch adds a few lists of synonymous values such that
release-gitter can make an attempt at matching the intended binary.
These lists of synonyms can be expanded to be more complete as time goes
on.

These synonyms are only used if there is no user provided mapping. In
the case that any user provided mapping exists, the map will be the
sole source of truth. Eg. If you provide a map for `Windows=>windows`,
no other values will be mapped and we won't assume that `Darwin=>macos`
anymore.

.drone.star

@@ -6,6 +6,7 @@ PYTHON_VERSIONS = [
     "3.9",
     "3.10",
     "3.11",
+    "3.12",
     "latest",
 ]
 
@@ -15,6 +16,19 @@ def main(ctx):
 
     # Run tests
     pipelines += tests()
+    pipelines += [{
+        "kind": "pipeline",
+        "name": "lint",
+        "workspace": get_workspace(),
+        "steps": [{
+            "name": "lint",
+            "image": "python:3",
+            "commands": [
+                "python -V",
+                "make lint",
+            ]
+        }]
+    }]
 
     # Add pypi push pipeline
     pipelines += push_to_pypi()
@@ -43,24 +57,20 @@ def tests():
         "name": "tests",
         "workspace": get_workspace(),
         "steps": [
-            tox_step("python:"+version)
+            test_step("python:"+version)
             for version in PYTHON_VERSIONS
         ],
     }]
 
 
 # Builds a single python test step
-def tox_step(docker_tag, python_cmd="python", tox_env="py3"):
+def test_step(docker_tag, python_cmd="python"):
     return {
         "name": "test {}".format(docker_tag.replace(":", "")),
         "image": docker_tag,
-        "environment": {
-            "TOXENV": tox_env,
-        },
         "commands": [
             "{} -V".format(python_cmd),
-            "pip install tox",
-            "tox",
+            "make clean-all test"
         ],
     }
 
@@ -110,36 +120,36 @@ def push_to_pypi():
     return [{
         "kind": "pipeline",
         "name": "deploy to pypi",
-        "depends_on": ["tests"],
+        "depends_on": ["tests", "lint"],
         "workspace": get_workspace(),
         "trigger": {
             "ref": [
-                "refs/heads/main",
+                # "refs/heads/main",
                 "refs/tags/v*",
             ],
         },
         "steps": [
-            {
-                "name": "push to test pypi",
-                "image": "python:3",
-                "environment": {
-                    "TWINE_USERNAME": {
-                        "from_secret": "PYPI_USERNAME",
-                    },
-                    "TWINE_PASSWORD": {
-                        "from_secret": "TEST_PYPI_PASSWORD",
-                    },
-                },
-                "commands": ["make upload-test"],
-            },
+            # {
+            #     "name": "push to test pypi",
+            #     "image": "python:3",
+            #     "environment": {
+            #         "HATCH_INDEX_USER": {
+            #             "from_secret": "PYPI_USERNAME",
+            #         },
+            #         "HATCH_INDEX_AUTH": {
+            #             "from_secret": "TEST_PYPI_PASSWORD",
+            #         },
+            #     },
+            #     "commands": ["make upload-test"],
+            # },
             {
                 "name": "push to pypi",
                 "image": "python:3",
                 "environment": {
-                    "TWINE_USERNAME": {
+                    "HATCH_INDEX_USER": {
                         "from_secret": "PYPI_USERNAME",
                     },
-                    "TWINE_PASSWORD": {
+                    "HATCH_INDEX_AUTH": {
                         "from_secret": "PYPI_PASSWORD",
                     },
                 },

.pre-commit-config.yaml

@@ -1,11 +1,11 @@
 ---
 repos:
   - repo: https://github.com/psf/black
-    rev: 22.3.0
+    rev: 24.4.2
     hooks:
       - id: black
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.1.0
+    rev: v4.6.0
     hooks:
       - id: check-added-large-files
       - id: check-merge-conflict
@@ -14,12 +14,12 @@ repos:
       - id: trailing-whitespace
       - id: name-tests-test
         exclude: tests/(common.py|util.py|(helpers|integration/factories)/(.+).py)
-  - repo: https://github.com/asottile/reorder_python_imports
-    rev: v3.0.1
+  - repo: https://github.com/pycqa/isort
+    rev: 5.13.2
     hooks:
-      - id: reorder-python-imports
+      - id: isort
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v0.942
+    rev: v1.10.0
     hooks:
       - id: mypy
         exclude: docs/

Makefile

@@ -5,7 +5,7 @@ ENV := venv
 .PHONY: default
 default: test
 
-# Creates virtualenv
+# Creates de virtualenv
 $(ENV):
 	python3 -m venv $(ENV)
 
@@ -13,87 +13,76 @@ $(ENV):
 $(ENV)/bin/$(NAME): $(ENV)
 	$(ENV)/bin/pip install -r requirements-dev.txt
 
-# Install tox into virtualenv for running tests
-$(ENV)/bin/tox: $(ENV)
-	$(ENV)/bin/pip install tox
-
-# Install wheel for building packages
-$(ENV)/bin/wheel: $(ENV)
-	$(ENV)/bin/pip install wheel
-
-# Install twine for uploading packages
-$(ENV)/bin/twine: $(ENV)
-	$(ENV)/bin/pip install twine
+# Install hatch into virtualenv for running tests
+$(ENV)/bin/hatch: $(ENV)
+	$(ENV)/bin/pip install hatch
 
 # Installs dev requirements to virtualenv
 .PHONY: devenv
 devenv: $(ENV)/bin/$(NAME)
 
-# Generates a smaller env for running tox, which builds it's own env
-.PHONY: test-env
-test-env: $(ENV)/bin/tox
-
-# Generates a small build env for building and uploading dists
-.PHONY: build-env
-build-env: $(ENV)/bin/twine $(ENV)/bin/wheel
-
-# Runs package
-.PHONY: run
-run: $(ENV)/bin/$(NAME)
-	$(ENV)/bin/$(NAME)
-
-# Runs tests with tox
+# Runs tests for current python
 .PHONY: test
-test: $(ENV)/bin/tox
-	$(ENV)/bin/tox
+test: $(ENV)/bin/hatch
+	$(ENV)/bin/hatch run +py=3 test:run
+
+# Runs test matrix
+.PHONY: test-matrix
+test-matrix: $(ENV)/bin/hatch
+	$(ENV)/bin/hatch run test:run
 
 # Builds wheel for package to upload
 .PHONY: build
-build: $(ENV)/bin/wheel
-	$(ENV)/bin/python setup.py sdist
-	$(ENV)/bin/python setup.py bdist_wheel
+build: $(ENV)/bin/hatch
+	$(ENV)/bin/hatch build
 
 # Verify that the python version matches the git tag so we don't push bad shas
 .PHONY: verify-tag-version
-verify-tag-version:
+verify-tag-version: $(ENV)/bin/hatch
 	$(eval TAG_NAME = $(shell [ -n "$(DRONE_TAG)" ] && echo $(DRONE_TAG) || git describe --tags --exact-match))
-	test "v$(shell python setup.py -V)" = "$(TAG_NAME)"
+	test "v$(shell $(ENV)/bin/hatch version)" = "$(TAG_NAME)"
 
-# Uses twine to upload to pypi
+# Upload to pypi
 .PHONY: upload
-upload: verify-tag-version build $(ENV)/bin/twine
-	$(ENV)/bin/twine upload dist/*
+upload: verify-tag-version build
+	$(ENV)/bin/hatch publish
 
 # Uses twine to upload to test pypi
 .PHONY: upload-test
-upload-test: build $(ENV)/bin/twine
-	$(ENV)/bin/twine check dist/*
-	$(ENV)/bin/twine upload --skip-existing --repository-url https://test.pypi.org/legacy/ dist/*
+upload-test: build
+	# Bump version to a post version based on num of commits since last tag to prevent overwriting
+	$(ENV)/bin/hatch version $(shell git describe --tags | sed 's/-[0-9a-z]*$$//')
+	$(ENV)/bin/hatch publish --repo test
 
 # Cleans all build, runtime, and test artifacts
 .PHONY: clean
 clean:
-	rm -fr ./build *.egg-info ./htmlcov ./.coverage ./.pytest_cache ./.tox
+	rm -fr ./build *.egg-info ./htmlcov ./.coverage ./.pytest_cache
 	find . -name '*.pyc' -delete
 	find . -name '__pycache__' -delete
 
 # Cleans dist and env
 .PHONY: dist-clean
 dist-clean: clean
+	-$(ENV)/bin/hatch env prune
 	rm -fr ./dist $(ENV)
 
+# Run linters
+.PHONY: lint
+lint: $(ENV)/bin/hatch
+	$(ENV)/bin/hatch run lint:all
+
 # Install pre-commit hooks
 .PHONY: install-hooks
 install-hooks: devenv
-	$(ENV)/bin/pre-commit install -f --install-hooks
+	$(ENV)/bin/hatch run lint:install-hooks
 
 # Generates test coverage
-.coverage:
-	$(ENV)/bin/tox
+.coverage: test
 
 # Builds coverage html
 htmlcov/index.html: .coverage
-	$(ENV)/bin/coverage html
+	$(ENV)/bin/hatch run coverage html
 
 # Opens coverage html in browser (on macOS and some Linux systems)
 .PHONY: open-coverage
@@ -107,7 +96,7 @@ docs-clean:
 
 # Builds docs
 docs/build/html/index.html:
-	$(ENV)/bin/tox -e docs
+	$(ENV)/bin/hatch run docs:build
 
 # Shorthand for building docs
 .PHONY: docs

docs/source/conf.py

@@ -13,6 +13,8 @@
 # sys.path.insert(0, os.path.abspath('.'))
 # -- Project information -----------------------------------------------------
 
+from __future__ import annotations
+
 project = "release-gitter"
 copyright = "2021, iamthefij"
 author = "iamthefij"

pseudo_builder.py

@@ -2,9 +2,12 @@
 This builder functions as a pseudo builder that instead downloads and installs a binary file using
 release-gitter based on a pyproject.toml file. It's a total hack...
 """
+
 from __future__ import annotations
 
+from dataclasses import dataclass
 from pathlib import Path
+from shutil import copy
 from shutil import copytree
 from shutil import move
 
@@ -14,11 +17,29 @@ from wheel.wheelfile import WheelFile
 import release_gitter as rg
 from release_gitter import removeprefix
 
-
 PACKAGE_NAME = "pseudo"
 
 
-def download(config) -> list[Path]:
+@dataclass
+class Config:
+    format: str
+    git_url: str
+    hostname: str
+    owner: str
+    repo: str
+    version: str | None = None
+    pre_release: bool = False
+    version_git_tag: bool = False
+    version_git_no_fetch: bool = False
+    map_system: dict[str, str] | None = None
+    map_arch: dict[str, str] | None = None
+    exec: str | None = None
+    extract_all: bool = False
+    extract_files: list[str] | None = None
+    include_extra_files: list[str] | None = None
+
+
+def download(config: Config) -> list[Path]:
     release = rg.fetch_release(
         rg.GitRemoteInfo(config.hostname, config.owner, config.repo), config.version
     )
@@ -39,26 +60,35 @@ def download(config) -> list[Path]:
     return files
 
 
-def read_metadata():
+def read_metadata() -> Config:
     config = toml.load("pyproject.toml").get("tool", {}).get("release-gitter")
     if not config:
         raise ValueError("Must have configuration in [tool.release-gitter]")
 
-    args = []
-    for key, value in config.items():
-        key = "--" + key
-        if key == "--format":
-            args += [value]
-        elif isinstance(value, dict):
-            for sub_key, sub_value in value.items():
-                args = [key, f"{sub_key}={sub_value}"] + args
-        elif isinstance(value, list):
-            for sub_value in value:
-                args = [key, sub_value] + args
-        else:
-            args = [key, value] + args
+    git_url = config.pop("git-url", None)
+    remote_info = rg.parse_git_remote(git_url)
 
-    return rg._parse_args(args)
+    args = Config(
+        format=config.pop("format"),
+        git_url=git_url,
+        hostname=config.pop("hostname", remote_info.hostname),
+        owner=config.pop("owner", remote_info.owner),
+        repo=config.pop("repo", remote_info.repo),
+    )
+
+    for key, value in config.items():
+        setattr(args, str(key).replace("-", "_"), value)
+
+    if args.version is None:
+        args.version = rg.read_version(
+            args.version_git_tag,
+            not args.version_git_no_fetch,
+        )
+
+    if args.extract_all:
+        args.extract_files = []
+
+    return args
 
 
 class _PseudoBuildBackend:
@@ -68,11 +98,11 @@ class _PseudoBuildBackend:
     def prepare_metadata_for_build_wheel(
         self, metadata_directory, config_settings=None
     ):
-        # Createa  .dist-info directory containing wheel metadata inside metadata_directory. Eg {metadata_directory}/{package}-{version}.dist-info/
+        # Create a .dist-info directory containing wheel metadata inside metadata_directory. Eg {metadata_directory}/{package}-{version}.dist-info/
         print("Prepare meta", metadata_directory, config_settings)
 
         metadata = read_metadata()
-        version = removeprefix(metadata.version, "v")
+        version = removeprefix(metadata.version, "v") if metadata.version else "0.0.0"
 
         # Returns distinfo dir?
         dist_info = Path(metadata_directory) / f"{PACKAGE_NAME}-{version}.dist-info"
@@ -119,7 +149,7 @@ class _PseudoBuildBackend:
         metadata_directory = Path(metadata_directory)
 
         metadata = read_metadata()
-        version = removeprefix(metadata.version, "v")
+        version = removeprefix(metadata.version, "v") if metadata.version else "0.0.0"
 
         wheel_directory = Path(wheel_directory)
         wheel_directory.mkdir(exist_ok=True)
@@ -134,7 +164,16 @@ class _PseudoBuildBackend:
         for file in files:
             move(file, wheel_scripts / file.name)
 
-        print(f"ls {wheel_directory}: {list(wheel_directory.glob('*'))}")
+        for file_name in metadata.include_extra_files or []:
+            file = Path(file_name)
+            if Path.cwd() in file.absolute().parents:
+                copy(file_name, wheel_scripts / file)
+            else:
+                raise ValueError(
+                    f"Cannot include any path that is not within the current directory: {file_name}"
+                )
+
+        print(f"ls {wheel_directory}: {list(wheel_directory.rglob('*'))}")
 
         wheel_filename = f"{PACKAGE_NAME}-{version}-py2.py3-none-any.whl"
         with WheelFile(wheel_directory / wheel_filename, "w") as wf:

pyproject.toml

@@ -0,0 +1,69 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "release-gitter"
+dynamic = ["version"]
+description = "Easily download releases from sites like Github and Gitea"
+readme = "README.md"
+license = "MIT"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "License :: OSI Approved :: MIT License",
+]
+authors = [
+    { name = "Ian Fijolek", email = "iamthefij@gmail.com" }
+]
+maintainers = [
+    { name = "Ian Fijolek", email = "iamthefij@gmail.com" }
+]
+requires-python = ">=3.7"
+dependencies = ["requests"]
+
+[project.optional-dependencies]
+builder = [
+    "toml",
+    "wheel",
+]
+
+[project.scripts]
+release-gitter = "release_gitter:main"
+
+[project.urls]
+Homepage = "https://git.iamthefij.com/iamthefij/release-gitter"
+
+[tool.hatch.version]
+path = "release_gitter.py"
+
+[tool.hatch.build]
+include = ["release_gitter.py", "pseudo_builder.py"]
+
+[tool.hatch.envs.test]
+dependencies = [
+    "coverage",
+]
+
+[tool.hatch.envs.test.scripts]
+run = [
+    "coverage erase",
+    "coverage run --source=release_gitter -m unittest discover . *_test.py",
+    "coverage report -m # --fail-under 70",
+]
+
+[[tool.hatch.envs.test.matrix]]
+python = ["3", "3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+
+[tool.hatch.envs.lint]
+detached = true
+dependencies = ["pre-commit"]
+
+[tool.hatch.envs.lint.scripts]
+all = "pre-commit run --all-files"
+install-hooks = "pre-commit install --install-hooks"
+
+[tool.isort]
+add_imports = ["from __future__ import annotations"]
+force_single_line = true
+profile = "black"

release_gitter.py

@@ -6,6 +6,7 @@ import platform
 from collections.abc import Sequence
 from dataclasses import dataclass
 from io import BytesIO
+from itertools import product
 from mimetypes import guess_type
 from pathlib import Path
 from subprocess import check_call
@@ -18,6 +19,8 @@ from zipfile import ZipFile
 
 import requests
 
+__version__ = "2.3.0"
+
 
 class UnsupportedContentTypeError(ValueError):
     pass
@@ -45,6 +48,31 @@ def removesuffix(s: str, suf: str) -> str:
         return s[: -len(suf)] if s and s.endswith(suf) else s
 
 
+SYSTEM_SYNONYMS: list[list[str]] = [
+    ["Darwin", "darwin", "MacOS", "macos", "macOS"],
+    ["Windows", "windows", "win", "win32", "win64"],
+    ["Linux", "linux"],
+]
+
+ARCH_SYNONYMS: list[list[str]] = [
+    ["arm"],
+    ["x86_64", "amd64", "AMD64"],
+    ["arm64", "aarch64", "armv8b", "armv8l"],
+    ["x86", "i386", "i686"],
+]
+
+
+def get_synonyms(value: str, thesaurus: list[list[str]]) -> list[str]:
+    """Gets synonym list for a given value."""
+    results = [value]
+
+    for l in thesaurus:
+        if value in l:
+            results += l
+
+    return results
+
+
 @dataclass
 class GitRemoteInfo:
     """Extracts information about a repository"""
@@ -243,21 +271,29 @@ def match_asset(
 
     system = platform.system()
     if system_mapping:
-        system = system_mapping.get(system, system)
+        systems = [system_mapping.get(system, system)]
+    else:
+        systems = get_synonyms(system, SYSTEM_SYNONYMS)
 
     arch = platform.machine()
     if arch_mapping:
-        arch = arch_mapping.get(arch, arch)
+        archs = [arch_mapping.get(arch, arch)]
+    else:
+        archs = get_synonyms(arch, ARCH_SYNONYMS)
 
     expected_names = {
         format.format(
-            version=normalized_version,
-            system=system,
-            arch=arch,
+            version=version_opt,
+            system=system_opt,
+            arch=arch_opt,
         )
-        for normalized_version in (
-            version.lstrip("v"),
-            "v" + version if not version.startswith("v") else version,
+        for version_opt, system_opt, arch_opt in product(
+            (
+                version.lstrip("v"),
+                "v" + version if not version.startswith("v") else version,
+            ),
+            systems,
+            archs,
         )
     }
 

release_gitter_test.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
 import unittest
+from itertools import chain
+from itertools import product
 from tarfile import TarFile
 from typing import Any
 from typing import Callable
 from typing import NamedTuple
-from typing import Optional
 from unittest.mock import MagicMock
 from unittest.mock import mock_open
 from unittest.mock import patch
@@ -21,10 +22,11 @@ class TestExpression(NamedTuple):
     args: list[Any]
     kwargs: dict[str, Any]
     expected: Any
-    exception: Optional[type[Exception]] = None
+    exception: type[Exception] | None = None
+    msg: str | None = None
 
     def run(self, f: Callable):
-        with self.t.subTest(f=f, args=self.args, kwargs=self.kwargs):
+        with self.t.subTest(msg=self.msg, f=f, args=self.args, kwargs=self.kwargs):
             try:
                 result = f(*self.args, **self.kwargs)
                 self.t.assertIsNone(
@@ -197,5 +199,277 @@ class TestContentTypeDetection(unittest.TestCase):
             )
 
 
+class TestMatchAsset(unittest.TestCase):
+    def test_match_asset_versions(self, *_):
+        # Input variations:
+        # Case 1: Version provided with prefix
+        # Case 2: Version provided without prefix
+        # Case 3: No version provided, tag exists in release
+        # These should be impossible
+        # Case 4: No version provided, tag doesn't exist in release but not in template
+        # Case 5: No version provided, tag doesn't exist in release and is in template
+
+        # Release variations:
+        # Case 1: tag_name with version prefix
+        # Case 2: tag_name without version prefix
+
+        # File variations:
+        # Case 1: file name with version prefix
+        # Case 2: file name without version prefix
+
+        def new_expression(version: str | None, tag_name: str, file_name: str):
+            release = {"tag_name": tag_name, "assets": [{"name": file_name}]}
+            expected = {"name": file_name}
+            return TestExpression(
+                self, [release, "file-{version}.zip", version], {}, expected
+            )
+
+        happy_cases = [
+            new_expression(version, tag_name, file_name)
+            for version, tag_name, file_name in product(
+                ("v1.0.0", "1.0.0", None),
+                ("v1.0.0", "1.0.0"),
+                ("file-v1.0.0.zip", "file-1.0.0.zip"),
+            )
+        ]
+        for test_case in happy_cases:
+            test_case.run(release_gitter.match_asset)
+
+    def test_match_asset_systems(self, *_):
+        # Input variations:
+        # Case 1: System mapping provided
+        # Case 2: No system mapping provided
+
+        # Test: We want to show that default matching will work out of the box with some values for the current machine
+        # Test: We want to show that non-standard mappings will always work if provided manually
+
+        def run_with_context(actual_system: str, *args, **kwargs):
+            with patch("platform.system", return_value=actual_system):
+                return release_gitter.match_asset(*args, **kwargs)
+
+        def new_expression(
+            actual_system: str,
+            system_mapping: dict[str, str] | None,
+            file_name: str,
+            expected: dict[str, str],
+            exception: type[Exception] | None = None,
+            msg: str | None = None,
+        ):
+            release = {
+                "name": "v1.0.0",
+                "tag_name": "v1.0.0",
+                "assets": [{"name": file_name}],
+            }
+            return TestExpression(
+                self,
+                [actual_system, release, "file-{system}.zip"],
+                {"system_mapping": system_mapping},
+                expected,
+                exception,
+                msg,
+            )
+
+        test_cases = chain(
+            [
+                new_expression(
+                    "Earth",
+                    None,
+                    "file-Earth.zip",
+                    {"name": "file-Earth.zip"},
+                    msg="Current system always included as an exact match synonym",
+                ),
+                new_expression(
+                    "Linux",
+                    {"Linux": "jumanji"},
+                    "file-jumanji.zip",
+                    {"name": "file-jumanji.zip"},
+                    msg="Non-standard system mapping works",
+                ),
+                new_expression(
+                    "Linux",
+                    {},
+                    "file-darwin.zip",
+                    {},
+                    ValueError,
+                    msg="No matching system",
+                ),
+            ],
+            # Test default mappings
+            (
+                new_expression(
+                    actual_system,
+                    None,
+                    file_name,
+                    {"name": file_name},
+                    msg="Default Linux mappings",
+                )
+                for actual_system, file_name in product(
+                    ("Linux", "linux"),
+                    ("file-Linux.zip", "file-linux.zip"),
+                )
+            ),
+            (
+                new_expression(
+                    actual_system,
+                    None,
+                    file_name,
+                    {"name": file_name},
+                    msg="Default macOS mappings",
+                )
+                for actual_system, file_name in product(
+                    ("Darwin", "darwin", "MacOS", "macos", "macOS"),
+                    (
+                        "file-Darwin.zip",
+                        "file-darwin.zip",
+                        "file-MacOS.zip",
+                        "file-macos.zip",
+                    ),
+                )
+            ),
+            (
+                new_expression(
+                    actual_system,
+                    None,
+                    file_name,
+                    {"name": file_name},
+                    msg="Default Windows mappings",
+                )
+                for actual_system, file_name in product(
+                    ("Windows", "windows", "win", "win32", "win64"),
+                    (
+                        "file-Windows.zip",
+                        "file-windows.zip",
+                        "file-win.zip",
+                        "file-win32.zip",
+                        "file-win64.zip",
+                    ),
+                )
+            ),
+        )
+        for test_case in test_cases:
+            test_case.run(run_with_context)
+
+    def test_match_asset_archs(self, *_):
+        # Input variations:
+        # Case 1: Arch mapping provided
+        # Case 2: No arch mapping provided
+
+        # Test: We want to show that default matching will work out of the box with some values for the current machine
+        # Test: We want to show that non-standard mappings will always work if provided manually
+
+        def run_with_context(actual_arch: str, *args, **kwargs):
+            with patch("platform.machine", return_value=actual_arch):
+                return release_gitter.match_asset(*args, **kwargs)
+
+        def new_expression(
+            actual_arch: str,
+            arch_mapping: dict[str, str] | None,
+            file_name: str,
+            expected: dict[str, str],
+            exception: type[Exception] | None = None,
+            msg: str | None = None,
+        ):
+            release = {
+                "name": "v1.0.0",
+                "tag_name": "v1.0.0",
+                "assets": [{"name": file_name}],
+            }
+            return TestExpression(
+                self,
+                [actual_arch, release, "file-{arch}.zip"],
+                {"arch_mapping": arch_mapping},
+                expected,
+                exception,
+                msg,
+            )
+
+        test_cases = chain(
+            [
+                new_expression(
+                    "Earth",
+                    None,
+                    "file-Earth.zip",
+                    {"name": "file-Earth.zip"},
+                    msg="Current arch always included as an exact match synonym",
+                ),
+                new_expression(
+                    "x86_64",
+                    {"x86_64": "jumanji"},
+                    "file-jumanji.zip",
+                    {"name": "file-jumanji.zip"},
+                    msg="Non-standard arch mapping works",
+                ),
+                new_expression(
+                    "x86_64",
+                    {},
+                    "file-arm.zip",
+                    {},
+                    ValueError,
+                    msg="No matching arch",
+                ),
+            ],
+            # Test default mappings
+            (
+                new_expression(
+                    actual_arch,
+                    None,
+                    file_name,
+                    {"name": file_name},
+                    msg="Default arm mappings",
+                )
+                for actual_arch, file_name in product(
+                    ("arm",),
+                    ("file-arm.zip",),
+                )
+            ),
+            (
+                new_expression(
+                    actual_arch,
+                    None,
+                    file_name,
+                    {"name": file_name},
+                    msg="Default amd64 mappings",
+                )
+                for actual_arch, file_name in product(
+                    ("amd64", "x86_64", "AMD64"),
+                    ("file-amd64.zip", "file-x86_64.zip"),
+                )
+            ),
+            (
+                new_expression(
+                    actual_arch,
+                    None,
+                    file_name,
+                    {"name": file_name},
+                    msg="Default arm64 mappings",
+                )
+                for actual_arch, file_name in product(
+                    ("arm64", "aarch64", "armv8b", "armv8l"),
+                    (
+                        "file-arm64.zip",
+                        "file-aarch64.zip",
+                        "file-armv8b.zip",
+                        "file-armv8l.zip",
+                    ),
+                )
+            ),
+            (
+                new_expression(
+                    actual_arch,
+                    None,
+                    file_name,
+                    {"name": file_name},
+                    msg="Default x86 mappings",
+                )
+                for actual_arch, file_name in product(
+                    ("x86", "i386", "i686"),
+                    ("file-x86.zip", "file-i386.zip", "file-i686.zip"),
+                )
+            ),
+        )
+        for test_case in test_cases:
+            test_case.run(run_with_context)
+
+
 if __name__ == "__main__":
     unittest.main()

requirements-dev.txt

@@ -1,5 +1,5 @@
 -e .
-coverage
+hatch
 mypy
 pre-commit
 types-requests

sample_pseudo_bin/pyproject.toml

@@ -11,6 +11,7 @@ version = "0.11.3"
 extract-files = [ "stylua" ]
 format = "stylua-{version}-{system}.zip"
 exec = "chmod +x stylua"
+
 [tool.release-gitter.map-system]
     Darwin = "macos"
     Windows = "win64"

setup.py

@@ -1,40 +0,0 @@
-from codecs import open
-from os import path
-
-from setuptools import setup
-
-here = path.abspath(path.dirname(__file__))
-
-# Get the long description from the README file
-with open(path.join(here, "README.md"), encoding="utf-8") as f:
-    long_description = f.read()
-
-setup(
-    name="release-gitter",
-    version="2.1.1",
-    description="Easily download releases from sites like Github and Gitea",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    url="https://git.iamthefij.com/iamthefij/release-gitter.git",
-    download_url=(
-        "https://git.iamthefij.com/iamthefij/release-gitter.git/archive/master.tar.gz"
-    ),
-    author="iamthefij",
-    author_email="",
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-        "Programming Language :: Python :: 3.10",
-    ],
-    keywords="",
-    py_modules=["release_gitter", "pseudo_builder"],
-    install_requires=["requests"],
-    extras_require={"builder": ["toml", "wheel"]},
-    entry_points={
-        "console_scripts": [
-            "release-gitter=release_gitter:main",
-        ],
-    },
-)

tox.ini

@@ -1,17 +0,0 @@
-[tox]
-envlist = py3,py37,py38,py39,py310,py311
-
-[testenv]
-deps =
-    -rrequirements-dev.txt
-commands =
-    coverage erase
-    coverage run --source=release_gitter -m unittest discover . {posargs:"*_test.py"}
-    coverage report -m # --fail-under 70
-    pre-commit run --all-files
-
-[testenv:pre-commit]
-deps =
-    pre-commit
-commands =
-    pre-commit {posargs}