alias-mapper 1.0.0__py3-none-any.whl

alias_mapper/formats/_io.py

@@ -0,0 +1,73 @@
+"""
+Transparent gzip handling for input and output files.
+
+Genomics files (FASTA, GFF, GTF) are very often distributed gzipped,
+sometimes without a telltale .gz suffix (e.g. a browser "download"
+endpoint). These helpers let the rest of the package open a path
+without caring whether it's compressed:
+
+  - reads sniff the gzip magic bytes, so a gzipped file works even if
+    its name doesn't end in .gz;
+  - writes compress when the chosen output path ends in .gz;
+  - format detection ignores a trailing .gz so `genome.fa.gz` still
+    resolves to the FASTA translator.
+
+This is the only place in the package that decides "is this gzip?",
+so the rule lives in one spot.
+"""
+
+import gzip
+import io
+from pathlib import Path
+
+# gzip streams begin with these two magic bytes (RFC 1952).
+_GZIP_MAGIC = b"\x1f\x8b"
+
+
+def is_gzip(path) -> bool:
+    """
+    Return True if `path` is gzip-compressed, decided by content not name.
+
+    Reads the first two bytes and checks for the gzip magic number, so a
+    gzipped file is handled regardless of whether it ends in .gz. Returns
+    False for a missing or unreadable file; the caller surfaces a clearer
+    "not found" error downstream.
+    """
+    try:
+        with open(path, "rb") as f:
+            return f.read(2) == _GZIP_MAGIC
+    except OSError:
+        return False
+
+
+def open_text_read(path, encoding: str = "utf-8") -> io.TextIOBase:
+    """Open `path` for text reading, decompressing if it is gzipped."""
+    if is_gzip(path):
+        return gzip.open(path, "rt", encoding=encoding)
+    return open(path, "r", encoding=encoding)
+
+
+def open_text_write(path, encoding: str = "utf-8") -> io.TextIOBase:
+    """
+    Open `path` for text writing, compressing if the name ends in .gz.
+
+    Output compression keys off the extension rather than content (there
+    is no content yet): `out.gff.gz` is written gzipped, `out.gff` plain.
+    """
+    if Path(path).suffix.lower() == ".gz":
+        return gzip.open(path, "wt", encoding=encoding)
+    return open(path, "w", encoding=encoding)
+
+
+def effective_suffix(path) -> str:
+    """
+    The format-relevant suffix, ignoring a trailing .gz.
+
+    `genome.fa.gz` -> `.fa`, `genome.gff` -> `.gff`, `genome.gz` -> ``.
+    Lower-cased. Used so extension-based format detection works on
+    compressed files.
+    """
+    p = Path(path)
+    if p.suffix.lower() == ".gz":
+        return Path(p.stem).suffix.lower()
+    return p.suffix.lower()

alias_mapper/formats/_resolve.py

@@ -0,0 +1,117 @@
+"""
+Fallback name resolution for alias lookups.
+
+The primary lookup is an exact dict hit: ``alias_map[name]``. When that
+misses, real-world inputs often carry the *same* identifier in a
+different surface form. Rather than fail those outright, we try a small,
+conservative set of normalizations and retry the lookup. The fallbacks
+only run on a miss, so the common path stays a single dict lookup.
+
+Two variant classes are handled, both low-risk normalizations of the
+same underlying accession (not fuzzy matching):
+
+  Version separator (.N <-> vN)
+    UCSC writes unplaced/unlocalized scaffolds with a 'v' version
+    separator (NW_013982187v1) where GenBank/RefSeq use a dot
+    (NW_013982187.1). If a name in one form misses, try the other.
+
+  ENA pipe-prefixed headers (ENA|<unversioned>|<versioned>)
+    ENA FASTA headers wrap the accession as 'ENA|ACC|ACC.v'. The bare
+    accession is what matches our columns, so on a miss we peel the ENA
+    wrapper and retry on the inner accession(s), most-likely first.
+
+Resolution order: exact name, then ENA-unwrapped accession(s), with a
+version-separator swap tried on each. First hit wins. None means the
+name is genuinely unmapped and the caller passes the line through
+unchanged, exactly as before this fallback existed.
+"""
+
+import re
+
+# A trailing version suffix in either surface form: ".1" or "v1".
+# Non-greedy with an end anchor so the LAST separator is the split point
+# (e.g. "GL000.2.1" -> base "GL000.2", version "1").
+_DOT_VERSION = re.compile(r"^(.*?)\.(\d+)$")
+_V_VERSION = re.compile(r"^(.*?)v(\d+)$")
+
+
+def _swap_version_suffix(name):
+    """
+    Yield the alternate version-suffix form of ``name``, if one applies.
+
+    "NW_013982187.1" -> "NW_013982187v1" and vice versa. Yields nothing
+    when the name has no trailing ".N" or "vN", so callers can iterate
+    unconditionally.
+    """
+    m = _DOT_VERSION.match(name)
+    if m:
+        yield f"{m.group(1)}v{m.group(2)}"
+        return
+    m = _V_VERSION.match(name)
+    if m:
+        yield f"{m.group(1)}.{m.group(2)}"
+
+
+def _strip_ena_prefix(name):
+    """
+    Yield the bare accession(s) from an 'ENA|...|...' header.
+
+    ENA|CAJVCV010000001|CAJVCV010000001.1 yields "CAJVCV010000001.1"
+    (versioned, the form that matches our columns) then
+    "CAJVCV010000001" (unversioned) as a secondary try. Yields nothing
+    when the name is not ENA-prefixed.
+    """
+    if "|" not in name:
+        return
+    fields = name.split("|")
+    if not fields or fields[0].upper() != "ENA":
+        return
+    rest = [f for f in fields[1:] if f]
+    # The versioned accession is usually the last field and most likely
+    # to match; the unversioned field is a secondary candidate.
+    for f in reversed(rest):
+        yield f
+
+
+def _candidates(name):
+    """
+    Generate lookup candidates for ``name`` in priority order.
+
+    The exact name is always yielded first, so a normal hit costs a
+    single dict lookup. Candidates are deduplicated while preserving
+    order, so each surface form is tried at most once.
+    """
+    seen = set()
+
+    def add(candidate):
+        if candidate and candidate not in seen:
+            seen.add(candidate)
+            return True
+        return False
+
+    # ENA-unwrapped accessions become additional base forms that the
+    # version-swap step can also act on (handles ENA-wrapped vN names).
+    bases = [name]
+    bases.extend(_strip_ena_prefix(name))
+
+    for base in bases:
+        if add(base):
+            yield base
+        for swapped in _swap_version_suffix(base):
+            if add(swapped):
+                yield swapped
+
+
+def resolve_alias(name: str, alias_map: dict) -> str | None:
+    """
+    Look up ``name`` in ``alias_map``, trying conservative fallbacks on a miss.
+
+    Returns the mapped target name, or None if no candidate form of the
+    name is present in the map. The first candidate is always the exact
+    name, so an ordinary hit is a single dict lookup with no overhead.
+    """
+    for candidate in _candidates(name):
+        hit = alias_map.get(candidate)
+        if hit is not None:
+            return hit
+    return None

alias_mapper/formats/base.py

@@ -0,0 +1,51 @@
+"""Abstract base class for file format translators."""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+
+class FileTranslator(ABC):
+    """
+    Translates sequence names in one file format.
+
+    Subclasses know which lines in their format contain sequence names
+    and how to rewrite them. Comments, headers, and blank lines should
+    pass through unchanged.
+    """
+
+    @abstractmethod
+    def translate_line(self, line: str, alias_map: dict, stats: dict) -> str:
+        """
+        Translate one line of input.
+
+        Args:
+            line:      One line from the input file (with trailing newline).
+            alias_map: {source_name -> target_name} dict from AliasSource.
+            stats:     Mutable dict with keys 'mapped' (int), 'unmapped'
+                       (int), and 'unmapped_examples' (set). The translator
+                       updates these in place.
+
+        Returns:
+            The translated line (with trailing newline). Lines that
+            don't contain a translatable sequence name are returned
+            unchanged.
+        """
+
+    @abstractmethod
+    def sample_names(self, path: Path, limit: int = 50) -> list[str]:
+        """
+        Read up to `limit` unique sequence names from the start of the file.
+
+        Used by auto-detection to decide which convention and assembly
+        the input file is using. Stops once `limit` unique names have
+        been collected, so this is O(limit) regardless of file size.
+
+        Args:
+            path:  Path to the input file.
+            limit: Maximum number of unique names to return.
+
+        Returns:
+            List of unique sequence names, preserving the order they
+            appeared in the file. May contain fewer than `limit` if
+            the file has fewer unique names.
+        """

alias_mapper/formats/fasta.py

@@ -0,0 +1,91 @@
+"""FASTA translator. Sequence name lives in the header line, after the '>'."""
+
+from pathlib import Path
+
+from .base import FileTranslator
+from ._io import open_text_read
+from ._resolve import resolve_alias
+
+
+class FastaTranslator(FileTranslator):
+    """
+    Translator for FASTA files.
+
+    FASTA structure:
+      - Header lines start with '>'. Format: '>NAME [WHITESPACE DESCRIPTION]'.
+        Only the NAME (first whitespace-separated token after '>') is the
+        sequence identifier. The description, if present, is preserved
+        verbatim including the exact whitespace between name and description.
+      - Sequence lines (the ACGT content) pass through unchanged.
+      - Blank lines pass through unchanged.
+
+    Translation rule:
+      - If the header's name resolves in the alias map, replace the name
+        with the target. Description is preserved exactly.
+      - If the name doesn't resolve, pass the whole line through
+        unchanged and count it as unmapped (same warn-and-pass-through
+        behavior as the GFF translator).
+
+    Name lookup goes through resolve_alias: an exact map hit is used when
+    present, and conservative fallbacks (ENA prefix strip, .N/vN
+    version-separator swap) are tried only when the exact name misses.
+    """
+
+    def translate_line(self, line: str, alias_map: dict, stats: dict) -> str:
+        if not line.startswith(">"):
+            # Sequence line, blank line, or anything else non-header.
+            return line
+
+        # Strip the trailing newline so we can reattach it exactly at the
+        # end. We don't use rstrip() generally — only the newline — to
+        # preserve any trailing whitespace inside the description.
+        if line.endswith("\n"):
+            body = line[1:-1]
+            newline = "\n"
+        else:
+            body = line[1:]
+            newline = ""
+
+        # Find the first whitespace character after '>'. Everything before
+        # it is the name; everything from there on (including the
+        # whitespace itself) is preserved as-is.
+        i = 0
+        while i < len(body) and not body[i].isspace():
+            i += 1
+        name = body[:i]
+        rest = body[i:]
+
+        if not name:
+            # Malformed header like '>' or '> description'. Nothing to
+            # translate; pass through unchanged.
+            return line
+
+        new_name = resolve_alias(name, alias_map)
+        if new_name is None:
+            stats["unmapped"] += 1
+            stats["unmapped_examples"].add(name)
+            return line
+
+        stats["mapped"] += 1
+        return f">{new_name}{rest}{newline}"
+
+    def sample_names(self, path: Path, limit: int = 50) -> list[str]:
+        names: list[str] = []
+        seen: set[str] = set()
+        with open_text_read(path) as f:
+            for line in f:
+                if not line.startswith(">"):
+                    continue
+                # Parse header the same way translate_line does, so a name
+                # collected here is the same string that would be looked up.
+                body = line[1:].rstrip("\n")
+                i = 0
+                while i < len(body) and not body[i].isspace():
+                    i += 1
+                name = body[:i]
+                if name and name not in seen:
+                    seen.add(name)
+                    names.append(name)
+                    if len(names) >= limit:
+                        break
+        return names

alias_mapper/formats/gff.py

@@ -0,0 +1,63 @@
+"""GFF / GTF translator. Both formats put the sequence name in column 1."""
+
+from pathlib import Path
+
+from .base import FileTranslator
+from ._io import open_text_read
+from ._resolve import resolve_alias
+
+
+class GffTranslator(FileTranslator):
+    """
+    Translator for GFF, GFF3, and GTF files.
+
+    All three are tab-separated with the sequence name in column 1.
+    Lines starting with '#' are comments/headers and pass through
+    unchanged.
+
+    Name lookup goes through resolve_alias, so an exact map hit is used
+    when present and a small set of conservative fallbacks (ENA prefix
+    strip, .N/vN version-separator swap) is tried only when the exact
+    name misses.
+
+    Known limitation: '##sequence-region <name> ...' metadata lines
+    contain a sequence name that v0.2 does not translate. The design
+    doc flags this as a v1 follow-up.
+    """
+
+    def translate_line(self, line: str, alias_map: dict, stats: dict) -> str:
+        if not line or line.startswith("#"):
+            return line
+
+        parts = line.rstrip("\n").split("\t")
+        if len(parts) < 1:
+            return line
+
+        seq_name = parts[0]
+        new_name = resolve_alias(seq_name, alias_map)
+        if new_name is None:
+            stats["unmapped"] += 1
+            stats["unmapped_examples"].add(seq_name)
+            return line
+
+        parts[0] = new_name
+        stats["mapped"] += 1
+        return "\t".join(parts) + "\n"
+
+    def sample_names(self, path: Path, limit: int = 50) -> list[str]:
+        names: list[str] = []
+        seen: set[str] = set()
+        with open_text_read(path) as f:
+            for line in f:
+                if not line or line.startswith("#"):
+                    continue
+                parts = line.rstrip("\n").split("\t")
+                if not parts:
+                    continue
+                name = parts[0]
+                if name and name not in seen:
+                    seen.add(name)
+                    names.append(name)
+                    if len(names) >= limit:
+                        break
+        return names

alias_mapper-1.0.0.dist-info/METADATA

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: alias-mapper
+Version: 1.0.0
+Summary: Translate chromosome/scaffold names in bioinformatics files between naming conventions
+Author: Max Reese
+License: MIT
+Project-URL: Homepage, https://github.com/guigolab/alias-mapper
+Project-URL: Issues, https://github.com/guigolab/alias-mapper/issues
+Keywords: bioinformatics,genomics,gff,fasta,naming-conventions,ncbi
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: platformdirs>=4.0
+Requires-Dist: certifi
+Provides-Extra: trusted
+Requires-Dist: truststore; extra == "trusted"
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# alias-mapper
+
+Translate chromosome and scaffold names in bioinformatics files
+between naming conventions (GenBank, RefSeq, UCSC, and others).
+
+## What it does
+
+Research files from different sources use different names for the same
+sequences: `chr1`, `NC_000001.11`, `CM000663.2`, and `1` can all refer
+to the same human chromosome. Files using different conventions can't
+be combined without translation.
+
+`alias-mapper` rewrites the sequence names in GFF, GTF, and FASTA
+files from one convention to another using a precomputed alias table
+built from NCBI assembly reports. Source convention and genome
+assembly are auto-detected from the input by default.
+
+## Install
+
+```bash
+pip install git+https://github.com/guigolab/alias-mapper.git
+```
+
+On networks that perform TLS inspection (corporate / institutional,
+e.g. CRG), also install the `trusted` extra so the tool uses the
+system keychain for cert verification:
+
+```bash
+pip install "alias-mapper[trusted] @ git+https://github.com/guigolab/alias-mapper.git"
+```
+
+The first time you run `convert`, the tool downloads the latest alias
+data (~100 MB) from GitHub Releases and builds a local SQLite database
+in your platform cache directory:
+
+- macOS:   `~/Library/Caches/alias-mapper/aliases.db`
+- Linux:   `~/.cache/alias-mapper/aliases.db`
+- Windows: `%LOCALAPPDATA%\alias-mapper\Cache\aliases.db`
+
+First-run setup takes about a minute. Subsequent runs use the cached
+database directly. If the database schema changes in a newer release,
+the cache is rebuilt automatically.
+
+## Quickstart
+
+```bash
+alias-mapper convert annotations.gff --to ucsc -o annotations.ucsc.gff
+```
+
+A summary on stderr reports how many rows were translated and how many
+had sequence names not in the alias database (those rows are passed
+through unchanged with a warning).
+
+## Usage
+
+```
+# single file
+alias-mapper convert <input> --to <convention> -o <output> [options]
+
+# multi-file: conform annotations to a reference FASTA (FASTA untouched)
+alias-mapper convert --fasta <ref> [<ann> ...] --out-dir <dir> [options]
+
+# multi-file: force the FASTA and annotations to one convention
+alias-mapper convert --fasta <ref> [<ann> ...] --overwrite-to <convention> --out-dir <dir>
+
+alias-mapper update
+```
+
+### Subcommands
+
+- **`convert`** — translate a single file, or a reference FASTA plus
+  its annotation files (multi-file mode; see [Multi-file mode](#multi-file-mode)).
+- **`update`** — re-download the latest alias data and rebuild the
+  cached database. Run manually when you want newer data.
+
+### Supported file types
+
+GFF (`.gff`, `.gff3`), GTF (`.gtf`), and FASTA (`.fa`, `.fasta`,
+`.fna`). The translator is picked by file extension.
+
+### Supported conventions
+
+`genbank`, `refseq`, `ucsc`, `sequence-name`, `assigned-molecule`.
+
+### Examples
+
+```bash
+# Translate from RefSeq to UCSC explicitly
+alias-mapper convert annotations.gff \
+    --from refseq --to ucsc \
+    -o out.gff
+
+# Pin the assembly when auto-detection is ambiguous
+alias-mapper convert annotations.gff \
+    --to ucsc \
+    --assembly GCF_000001405.40 \
+    -o out.gff
+
+# FASTA — same syntax, different file
+alias-mapper convert reference.fa \
+    --from genbank --to sequence-name \
+    --assembly GCA_963924405.1 \
+    -o reference.renamed.fa
+
+# Multi-file conform: rewrite the annotations to match reference.fa's
+# own convention; reference.fa is left untouched
+alias-mapper convert --fasta reference.fa genes.gff peaks.bed.gff \
+    --out-dir conformed/
+
+# Multi-file overwrite: force reference.fa and its annotations to UCSC
+alias-mapper convert --fasta reference.fa genes.gff \
+    --overwrite-to ucsc --out-dir ucsc_out/
+
+# Refresh the cached alias data
+alias-mapper update
+```
+
+### Multi-file mode
+
+Pass `--fasta <ref>` to process a reference FASTA together with its
+annotation files in one invocation. The assembly is detected once from
+the FASTA and the alias table is loaded once for the whole batch.
+Outputs go to `--out-dir`, named `<stem>.<convention>.<ext>` (gzip
+preserved).
+
+There are two modes:
+
+- **Conform** (the default, when `--overwrite-to` is omitted): each
+  annotation is rewritten to match the FASTA's *own* convention, and
+  the FASTA is left unchanged. Use this to make a set of annotations
+  agree with a genome you already have. The FASTA is not copied into
+  the output directory, since it is unchanged.
+- **Overwrite** (`--overwrite-to <convention>`): the FASTA and every
+  annotation are converted to the named convention.
+
+`--to` is single-file only; in `--fasta` mode use `--overwrite-to`
+(or omit it to conform).
+
+### Flags (`convert`)
+
+| Flag             | Mode        | Purpose                                                       |
+| ---------------- | ----------- | ------------------------------------------------------------- |
+| `--to`           | single-file | Target naming convention (required in single-file mode)       |
+| `-o`             | single-file | Output path                                                   |
+| `--fasta`        | multi-file  | Reference FASTA; enables multi-file mode                      |
+| `--overwrite-to` | multi-file  | Force the FASTA and all annotations to this convention        |
+| `--out-dir`      | multi-file  | Output directory for the converted files                      |
+| `--from`         | both        | Source convention. Auto-detected if absent (not used to conform) |
+| `--assembly`     | both        | Assembly accession. Auto-detected if absent                   |
+| `--alias-db`     | both        | Path to a specific alias SQLite database (overrides cache)    |
+
+### Auto-detection
+
+When `--from` or `--assembly` is omitted, the tool reads up to 50
+unique sequence names from the input and scores them against the
+database. It commits to a result only when the top candidate has at
+least 5 matches and beats the runner-up by 2× or more. Otherwise it
+errors out and asks for the flag explicitly.
+
+### Unmapped names
+
+If a sequence name in the input isn't in the alias database, the line
+is written to the output unchanged and counted in the unmapped total.
+Up to five example names are printed at the end of the run so you can
+see what didn't translate.
+
+Before giving up on a name, the tool tries a couple of conservative
+fallbacks: swapping a UCSC-style `vN` version separator for the `.N`
+form (and vice versa), and stripping an `ENA|...|accession` header
+wrapper down to the bare accession. These only run when the exact name
+isn't found, so they never override a direct match.
+
+## Data updates
+
+A weekly GitHub Actions workflow rebuilds the alias dataset from
+NCBI's published assembly summaries and publishes it as a
+`data-YYYY-MM-DD` GitHub Release. Each release ships three artifacts:
+
+- `aliases.tsv.gz` — the merged-row alias data the CLI consumes.
+- `historical.tsv.gz` — dead-accession lookup with suppression dates
+  and best-effort replacements.
+- `failures.tsv` — per-assembly collection failure log.
+
+## More
+
+See [`docs/design.md`](docs/design.md) for architecture, design
+decisions, and direction.

alias_mapper-1.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+alias_mapper/__init__.py,sha256=O0JAPQuXu12gyFvu0kp_KSoZed5yAWYthF0X5l5ZXdE,197
+alias_mapper/_ssl.py,sha256=mEiEkR_I92WSvS1hrRrKx39iddiS0e5MqIhZopDFH5A,1219
+alias_mapper/alias_source.py,sha256=y4WduMiDOJoUqW0uH3hr3ZFx22dp28VS82xh3wi8XKA,12350
+alias_mapper/bootstrap.py,sha256=Xxb9LiXGq9U49JzxqlIHqIYqGL-kCyOwRa7OIg6248A,11453
+alias_mapper/build_alias_db.py,sha256=9QsAXfYsf5mKOOpIekUMxoINIaa9gdOeHfW0b7geoT4,15006
+alias_mapper/cli.py,sha256=nQKO0SpdNEoTkclKiThOZIuSZh3utFrCCs9gBP9DBUk,21935
+alias_mapper/formats/__init__.py,sha256=YHS55y63dO67zwbbnFC_mrRQNlAxueKA7voydgFiHsk,2091
+alias_mapper/formats/_io.py,sha256=BbNLeW0hAlalBDrmnbGde0KAu1UVfKw-hjHlBkO6eX4,2429
+alias_mapper/formats/_resolve.py,sha256=MWtpZfqT6tLc1H2yhq2_4s0hRQvCZYQ3P9Axc1Pyedo,4105
+alias_mapper/formats/base.py,sha256=sXNjtI8RYaTayVJ83yKTpoNIFiH4QHefRSo9vNTPGwY,1805
+alias_mapper/formats/fasta.py,sha256=gVic5h7Ww_H1BbpA5KAAEWKE-DlQJv9sMLX_VEi9d4A,3441
+alias_mapper/formats/gff.py,sha256=7TITMSxfN10nF72c9BOb7Vd9YXLJfrlA-yhqrKh3gL0,2069
+alias_mapper-1.0.0.dist-info/licenses/LICENSE,sha256=KT4Ss1FW0agpBfeCymuPj_WaHXCTmBw-Pa13nSOvYFU,1066
+alias_mapper-1.0.0.dist-info/METADATA,sha256=3jBwGt2qVFKP2C3xDCr1Xji3x297t58812VdrU8PW0g,8237
+alias_mapper-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+alias_mapper-1.0.0.dist-info/entry_points.txt,sha256=5N8tR8vDiFTXnLW7skIV1si8w9SWN6I30tPsdjyY_EM,55
+alias_mapper-1.0.0.dist-info/top_level.txt,sha256=TdP8YWOGPZqC_3it-AUCX47RPt29G_dnxaG_l3CFRW0,13
+alias_mapper-1.0.0.dist-info/RECORD,,

alias_mapper-1.0.0.dist-info/WHEEL

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

alias_mapper-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+alias-mapper = alias_mapper.cli:main

alias_mapper-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Max Reese
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

alias_mapper-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+alias_mapper