pysidtracker 0.1.0__py3-none-any.whl

pysidtracker/__init__.py

@@ -0,0 +1,50 @@
+"""Shared base for the pure-Python C64 SID tracker parsers.
+
+Provides the one PSID/RSID container parser, the loaded-image model, the source
+dispatch, the error hierarchy, and the packed/relocating playroutine detector
+that the ``py*`` format packages (pygoattracker, pysidwizard, pydmcsid,
+pyfuturecomposer, pymusicassembler, pydefmon, pyjch) build on for a consistent
+API.
+"""
+
+from .base import BaseSidParser
+from .detect import (
+    Detection,
+    PlayroutineKind,
+    Recognizer,
+    detect_playroutine,
+    run_init,
+)
+from .errors import (
+    EmulatorUnavailable,
+    SidError,
+    SidFormatError,
+    SidParseError,
+)
+from .header import PSID_MAGIC, RSID_MAGIC, SidHeader, parse_sid_header
+from .image import MEM_SIZE, SidImage
+from .source import Source, read_bytes
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "BaseSidParser",
+    "Detection",
+    "EmulatorUnavailable",
+    "MEM_SIZE",
+    "PSID_MAGIC",
+    "PlayroutineKind",
+    "RSID_MAGIC",
+    "Recognizer",
+    "SidError",
+    "SidFormatError",
+    "SidHeader",
+    "SidImage",
+    "SidParseError",
+    "Source",
+    "__version__",
+    "detect_playroutine",
+    "parse_sid_header",
+    "read_bytes",
+    "run_init",
+]

pysidtracker/_scan.py

@@ -0,0 +1,115 @@
+"""Fast searches over a 64 KiB C64 memory image.
+
+The static playroutine-recognition step scans the loaded image for known byte
+signatures and for anchor tables (a low half immediately followed by a matching
+high half, e.g. the split note-frequency table many players embed). Both are
+numpy-accelerated when numpy is importable and fall back to pure-stdlib
+scanning otherwise, so the base install stays dependency-free.
+"""
+
+from __future__ import annotations
+
+from typing import List, Optional, Sequence
+
+try:  # numpy is an optional accelerator, never required.
+    import numpy as _np
+except ImportError:  # pragma: no cover - exercised only without numpy
+    _np = None
+
+
+def find_all(mem: Sequence[int], needle: bytes, start: int = 0) -> List[int]:
+    """Return every index >= ``start`` where ``needle`` occurs in ``mem``."""
+    if not needle:
+        return []
+    buf = bytes(mem)
+    hits = []
+    pos = buf.find(needle, start)
+    while pos != -1:
+        hits.append(pos)
+        pos = buf.find(needle, pos + 1)
+    return hits
+
+
+def find_first(mem: Sequence[int], needle: bytes, start: int = 0) -> int:
+    """Return the first index >= ``start`` of ``needle`` in ``mem``, or ``-1``."""
+    return bytes(mem).find(needle, start)
+
+
+def find_split_table(
+    mem: Sequence[int],
+    lo: Sequence[int],
+    hi: Sequence[int],
+    *,
+    min_length: int = 8,
+    limit: int = 0x10000,
+) -> Optional[tuple]:
+    """Locate a split lo/hi table anchor in ``mem``.
+
+    Players commonly embed a two-column table as ``lo[first:first+n]`` directly
+    followed by ``hi[first:first+n]`` (a contiguous slice of a longer known
+    table, ``lo``/``hi``). Returns ``(addr, first, length)`` for the longest
+    such match with ``length >= min_length``, or ``None``. ``addr`` is the start
+    of the low column; the high column starts at ``addr + length``.
+    """
+    lo = bytes(lo)
+    hi = bytes(hi)
+    n = len(lo)
+    if n == 0 or len(hi) != n:
+        return None
+    limit = min(limit, len(mem))
+    if _np is not None:
+        return _find_split_table_np(mem, lo, hi, n, min_length, limit)
+    return _find_split_table_py(mem, lo, hi, n, min_length, limit)
+
+
+def _find_split_table_py(mem, lo, hi, n, min_length, limit):
+    best = None
+    # A table needs 2*min_length bytes, so the last viable start is
+    # ``limit - 2 * min_length`` inclusive (a table ending exactly at ``limit``).
+    for addr in range(0, limit - 2 * min_length + 1):
+        first = mem[addr]
+        for fn in range(n):
+            if lo[fn] != first:
+                continue
+            length = 0
+            while (
+                fn + length < n
+                and addr + length < limit
+                and mem[addr + length] == lo[fn + length]
+            ):
+                length += 1
+            if length < min_length or addr + 2 * length > limit:
+                continue
+            if all(mem[addr + length + i] == hi[fn + i] for i in range(length)):
+                if best is None or length > best[2]:
+                    best = (addr, fn, length)
+    return best
+
+
+def _find_split_table_np(mem, lo, hi, n, min_length, limit):
+    arr = _np.frombuffer(bytes(mem)[:limit], dtype=_np.uint8)
+    lo_np = _np.frombuffer(lo, dtype=_np.uint8)
+    best = None
+    # For each possible table offset ``fn`` and run length, a match requires the
+    # lo slice at ``addr`` and the hi slice at ``addr+length`` to line up. We
+    # scan candidate start addresses cheaply by matching the first lo byte, then
+    # verify/extend in the (small) candidate set.
+    for fn in range(n):
+        starts = _np.nonzero(arr == lo_np[fn])[0]
+        for addr in starts.tolist():
+            length = 0
+            while (
+                fn + length < n
+                and addr + length < limit
+                and arr[addr + length] == lo[fn + length]
+            ):
+                length += 1
+            if length < min_length or addr + 2 * length > limit:
+                continue
+            if (
+                bytes(arr[addr + length : addr + 2 * length].tolist())
+                == hi[fn : fn + length]
+            ):
+                if best is None or length > best[2]:
+                    best = (addr, fn, length)
+    return best

pysidtracker/base.py

@@ -0,0 +1,72 @@
+"""The base class every ``py*`` SID parser subclasses for a consistent API.
+
+A concrete parser implements :meth:`BaseSidParser.parse` (bytes -> its own song
+model) and, to gain packed/relocating detection for free, the cheap
+:meth:`BaseSidParser.recognize` predicate. In return it inherits a uniform
+``read``/``parse``/``detect`` surface identical across every format.
+"""
+
+from __future__ import annotations
+
+import abc
+from typing import Any
+
+from .detect import Detection, detect_playroutine
+from .errors import SidParseError
+from .image import SidImage
+from .source import Source, read_bytes
+
+
+class BaseSidParser(abc.ABC):
+    """Abstract base giving every SID parser the same entry points.
+
+    Subclass responsibilities:
+      * :meth:`parse` -- decode raw container bytes into the format's song model.
+      * :meth:`recognize` (optional) -- return a truthy anchor when the format's
+        signature is present in a loaded image, enabling :meth:`detect`.
+
+    Inherited for free: :meth:`read` (path/bytes/file dispatch) and
+    :meth:`detect` (untrustworthy-header handling via
+    :func:`pysidtracker.detect.detect_playroutine`).
+    """
+
+    #: Exception type raised for parse failures; subclasses may narrow this to
+    #: their own :class:`~pysidtracker.errors.SidParseError` subclass.
+    error_class: type = SidParseError
+
+    @abc.abstractmethod
+    def parse(self, data: bytes, **kwargs: Any) -> Any:
+        """Decode raw ``.sid``/``.prg`` ``data`` into the format's song model."""
+
+    def read(self, src: Source, **kwargs: Any) -> Any:
+        """Read ``src`` (path, ``bytes``, or file-like) and :meth:`parse` it."""
+        return self.parse(read_bytes(src), **kwargs)
+
+    def load_image(self, data: bytes) -> SidImage:
+        """Load ``data`` into a :class:`~pysidtracker.image.SidImage`."""
+        return SidImage.from_bytes(data)
+
+    def recognize(self, image: SidImage) -> object:  # pylint: disable=unused-argument
+        """Return a truthy anchor if this format is present in ``image``.
+
+        The default returns ``None`` (no static recogniser). Override to enable
+        :meth:`detect`.
+        """
+        return None
+
+    def detect(
+        self,
+        src: Source,
+        *,
+        init: bool = True,
+        subtune: int = 0,
+    ) -> Detection:
+        """Classify how ``src`` presents its playroutine data.
+
+        See :func:`pysidtracker.detect.detect_playroutine`. Uses
+        :meth:`recognize`; returns
+        :attr:`~pysidtracker.detect.PlayroutineKind.UNKNOWN` for parsers that do
+        not override it.
+        """
+        image = self.load_image(read_bytes(src))
+        return detect_playroutine(image, self.recognize, init=init, subtune=subtune)

pysidtracker/detect.py

@@ -0,0 +1,181 @@
+"""Detect compressed / packed / relocating playroutines in a first parse.
+
+A ``.sid`` header advertises a load address, an init address and a subtune
+count, but for many real tunes these describe a *loader* or *packer*, not the
+playroutine: the actual song tables only exist after the init routine unpacks or
+relocates them into memory. The header is therefore untrustworthy for locating
+data.
+
+The shared strategy (generalised from pygoattracker's ``.sid`` decompiler):
+
+1. **Static recognition.** Ask the format's ``recognize`` callback to find its
+   signature/anchor in the freshly loaded image. If it succeeds the tune is
+   :attr:`PlayroutineKind.DIRECT` -- a plain direct-load image.
+2. **Emulated init.** Otherwise the playroutine is packed/relocating: run its
+   init routine in a 6502 emulator so the data lands where it really goes, then
+   recognise again. Whether init had to *expand* memory (decompression) or only
+   *move*/rewrite the existing image classifies it as
+   :attr:`PlayroutineKind.PACKED` vs :attr:`PlayroutineKind.RELOCATED`.
+3. If recognition still fails, :attr:`PlayroutineKind.UNKNOWN`.
+
+Each parser supplies only the cheap ``recognize`` predicate; this module owns
+the untrustworthy-header handling so every format gets it identically.
+"""
+
+from __future__ import annotations
+
+import enum
+from dataclasses import dataclass
+from typing import Callable
+
+from .errors import EmulatorUnavailable, SidParseError
+from .image import MEM_SIZE, SidImage
+
+# recognize(image) -> anchor (any truthy value) if the format is found, else None.
+Recognizer = Callable[[SidImage], object]
+
+
+class PlayroutineKind(enum.Enum):
+    """How a tune's playroutine presents its data in the loaded image."""
+
+    DIRECT = "direct"  # data found statically, as loaded
+    RELOCATED = "relocated"  # found only after init moved/rewrote the image
+    PACKED = "packed"  # found only after init expanded (decompressed) memory
+    UNKNOWN = "unknown"  # not recognised, even after running init
+
+
+@dataclass
+class Detection:
+    """Outcome of :func:`detect_playroutine`.
+
+    Attributes:
+      kind: the :class:`PlayroutineKind`.
+      ran_init: whether the init routine had to be emulated.
+      anchor: whatever the ``recognize`` callback returned (``None`` if
+        unrecognised) -- often the address/offset it found, reusable by the
+        caller's full parse.
+      changed_inside: bytes within the originally loaded region that init
+        altered (self-modifying / in-place unpacking).
+      written_outside: bytes outside the originally loaded region that init
+        wrote (relocation targets / decompression output).
+    """
+
+    kind: PlayroutineKind
+    ran_init: bool
+    anchor: object = None
+    changed_inside: int = 0
+    written_outside: int = 0
+
+    @property
+    def recognised(self) -> bool:
+        return self.kind is not PlayroutineKind.UNKNOWN
+
+    @property
+    def trustworthy_header(self) -> bool:
+        """True when the header described the data directly (no init needed)."""
+        return self.kind is PlayroutineKind.DIRECT
+
+
+def detect_playroutine(
+    image: SidImage,
+    recognize: Recognizer,
+    *,
+    init: bool = True,
+    subtune: int = 0,
+) -> Detection:
+    """Classify how ``image`` presents its playroutine data.
+
+    ``recognize`` inspects the (possibly unpacked) image and returns a truthy
+    anchor when it finds the format, else ``None``. When static recognition
+    fails and ``init`` is true, the init routine is emulated (requires the
+    optional ``py65`` dependency) and recognition retried.
+
+    Raises :class:`EmulatorUnavailable` if emulation is needed but ``py65`` is
+    not installed.
+    """
+    anchor = recognize(image)
+    if anchor:
+        return Detection(PlayroutineKind.DIRECT, ran_init=False, anchor=anchor)
+    if not init:
+        return Detection(PlayroutineKind.UNKNOWN, ran_init=False)
+
+    orig_load, orig_end = image.load, image.end
+    snapshot = bytes(image.mem[orig_load:orig_end])
+    run_init(image, subtune=subtune)
+    image.end = MEM_SIZE  # init may have scattered data anywhere
+
+    changed_inside = _count_changed(image.mem, orig_load, snapshot)
+    written_outside = _count_written_outside(image.mem, orig_load, orig_end)
+
+    anchor = recognize(image)
+    if not anchor:
+        kind = PlayroutineKind.UNKNOWN
+    elif written_outside > changed_inside:
+        kind = PlayroutineKind.PACKED
+    else:
+        kind = PlayroutineKind.RELOCATED
+    return Detection(
+        kind,
+        ran_init=True,
+        anchor=anchor,
+        changed_inside=changed_inside,
+        written_outside=written_outside,
+    )
+
+
+# The 6502 stack page is scratch space the init run (and our return-address
+# stub) churns; it is never song data, so it is excluded from the diff metrics.
+_STACK_LO = 0x0100
+_STACK_HI = 0x0200
+
+
+def _count_changed(mem: bytearray, load: int, snapshot: bytes) -> int:
+    return sum(1 for i, b in enumerate(snapshot) if mem[load + i] != b)
+
+
+def _count_written_outside(mem: bytearray, load: int, end: int) -> int:
+    written = 0
+    for addr, value in enumerate(mem):
+        if not value:
+            continue
+        if load <= addr < end:
+            continue
+        if _STACK_LO <= addr < _STACK_HI:
+            continue
+        written += 1
+    return written
+
+
+def run_init(image: SidImage, subtune: int = 0, max_cycles: int = 8_000_000) -> None:
+    """Run the tune's init routine in a 6502 emulator so data lands in place.
+
+    Mutates ``image.mem`` directly. ``subtune`` is passed to init in the
+    accumulator (the SID calling convention). Requires the optional ``py65``
+    dependency; raises :class:`EmulatorUnavailable` if it is missing and
+    :class:`SidParseError` if the image has no init address to call.
+    """
+    if image.header is None:
+        raise SidParseError("cannot run init: image has no SID header")
+    init_address = image.header.init_address or image.header.real_load_address
+    try:
+        from py65.devices.mpu6502 import MPU
+    except ImportError as exc:  # pragma: no cover - optional dependency
+        raise EmulatorUnavailable(
+            "py65 is required to unpack this tune (packed/relocating): "
+            "pip install pysidtracker[emu]"
+        ) from exc
+    mpu = MPU(memory=image.mem)
+    start_sp = mpu.sp
+    # Push a return address so the routine's final RTS lands back in our stub
+    # and the loop below (sp climbing back above start_sp) terminates.
+    image.mem[0x0100 + mpu.sp] = 0x00
+    mpu.sp = (mpu.sp - 1) & 0xFF
+    image.mem[0x0100 + mpu.sp] = 0x01
+    mpu.sp = (mpu.sp - 1) & 0xFF
+    mpu.a = subtune & 0xFF
+    mpu.pc = init_address
+    start_cycles = mpu.processorCycles
+    while mpu.sp < start_sp:
+        mpu.step()
+        if mpu.processorCycles - start_cycles > max_cycles:
+            break

pysidtracker/errors.py

@@ -0,0 +1,28 @@
+"""Exception hierarchy shared by the ``py*`` SID tracker parsers.
+
+Every parser raises errors that derive from :class:`SidError`, so a caller can
+``except SidError`` across formats. Individual packages subclass these to keep
+their own format-specific names (e.g. a GoatTracker ``SngParseError``) while
+staying catchable through the shared base.
+"""
+
+
+class SidError(Exception):
+    """Base class for all pysidtracker errors."""
+
+
+class SidParseError(SidError):
+    """A ``.sid``/``.prg`` image could not be parsed."""
+
+
+class SidFormatError(SidParseError):
+    """The container is not a recognised PSID/RSID/PRG, or is truncated."""
+
+
+class EmulatorUnavailable(SidError):
+    """The optional 6502 emulator (``py65``) is needed but not installed.
+
+    Raised when detection has to run a packed/relocating tune's init routine to
+    materialise its data and :mod:`py65` is missing. Install the extra with
+    ``pip install pysidtracker[emu]``.
+    """

pysidtracker/header.py

@@ -0,0 +1,151 @@
+"""PSID/RSID (``.sid``) container-header parsing.
+
+The outer SID *container* is a big-endian header (documented at
+https://www.hvsc.c64.org/download/C64Music/DOCUMENTS/SID_file_format.txt)
+wrapping a raw C64 memory image (player code + song data). Every parser in the
+family unwraps this identically; :func:`parse_sid_header` is that one
+implementation.
+
+The header's advertised load/init/play addresses and subtune count are *not*
+trustworthy for packed, relocating, or crunched tunes -- the real layout only
+exists after the init routine runs. This module resolves the on-disk fields;
+:mod:`pysidtracker.detect` handles the untrustworthy-header problem.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .errors import SidFormatError
+
+PSID_MAGIC = b"PSID"
+RSID_MAGIC = b"RSID"
+
+# Field offsets within the (big-endian) SID container header.
+_MAGIC_POS = 0x00
+_VERSION_POS = 0x04
+_DATA_OFFSET_POS = 0x06
+_LOAD_ADDRESS_POS = 0x08
+_INIT_ADDRESS_POS = 0x0A
+_PLAY_ADDRESS_POS = 0x0C
+_SONGS_POS = 0x0E
+_START_SONG_POS = 0x10
+_NAME_POS = 0x16
+_AUTHOR_POS = 0x36
+_RELEASED_POS = 0x56
+_STR_LEN = 0x20
+_FLAGS_POS = 0x76
+_SECOND_SID_POS = 0x7A  # v3+: address byte of the 2nd SID (0 => single SID)
+_THIRD_SID_POS = 0x7C  # v4+: address byte of the 3rd SID
+
+
+def _u16be(data: bytes, pos: int) -> int:
+    return (data[pos] << 8) | data[pos + 1]
+
+
+def _decode_str(raw: bytes) -> str:
+    return raw.split(b"\0", 1)[0].decode("latin-1")
+
+
+@dataclass
+class SidHeader:
+    """Decoded SID-container header fields.
+
+    :attr:`load_address` is the raw header field (``0`` for the common
+    "load address lives in the first two bytes of the data" case);
+    :attr:`real_load_address` is the resolved C64 address the image loads at and
+    :attr:`data_start` is the file offset of the first byte of that image.
+    """
+
+    magic: bytes
+    version: int
+    data_offset: int
+    load_address: int
+    init_address: int
+    play_address: int
+    songs: int
+    start_song: int
+    name: str
+    author: str
+    released: str
+    flags: int
+    second_sid: int
+    third_sid: int
+    real_load_address: int
+    data_start: int
+
+    @property
+    def is_psid(self) -> bool:
+        return self.magic == PSID_MAGIC
+
+    @property
+    def is_rsid(self) -> bool:
+        return self.magic == RSID_MAGIC
+
+    @property
+    def is_multi_sid(self) -> bool:
+        """True if the header advertises a 2nd/3rd/4th SID chip."""
+        return self.version >= 3 and (self.second_sid != 0 or self.third_sid != 0)
+
+
+def parse_sid_header(data: bytes) -> SidHeader:
+    """Decode the PSID/RSID container header at the start of ``data``.
+
+    Raises :class:`SidFormatError` if the magic is neither ``PSID`` nor ``RSID``
+    or the header is truncated. When the header ``loadAddress`` field is ``0``
+    the real load address is read from the first little-endian word of the data
+    area (and :attr:`SidHeader.data_start` skips it).
+    """
+    if len(data) < _START_SONG_POS + 2:
+        raise SidFormatError("input is too short to contain a SID header")
+    magic = bytes(data[_MAGIC_POS : _MAGIC_POS + 4])
+    if magic not in (PSID_MAGIC, RSID_MAGIC):
+        raise SidFormatError(
+            "not a SID file (expected 'PSID' or 'RSID' magic at offset 0, "
+            f"found {magic!r})"
+        )
+    version = _u16be(data, _VERSION_POS)
+    data_offset = _u16be(data, _DATA_OFFSET_POS)
+    load_address = _u16be(data, _LOAD_ADDRESS_POS)
+    init_address = _u16be(data, _INIT_ADDRESS_POS)
+    play_address = _u16be(data, _PLAY_ADDRESS_POS)
+    songs = _u16be(data, _SONGS_POS)
+    start_song = _u16be(data, _START_SONG_POS)
+    name = _decode_str(data[_NAME_POS : _NAME_POS + _STR_LEN])
+    author = _decode_str(data[_AUTHOR_POS : _AUTHOR_POS + _STR_LEN])
+    released = _decode_str(data[_RELEASED_POS : _RELEASED_POS + _STR_LEN])
+    flags = (
+        _u16be(data, _FLAGS_POS) if version >= 2 and len(data) >= _FLAGS_POS + 2 else 0
+    )
+    second_sid = data[_SECOND_SID_POS] if len(data) > _SECOND_SID_POS else 0
+    third_sid = data[_THIRD_SID_POS] if len(data) > _THIRD_SID_POS else 0
+
+    if load_address == 0:
+        if data_offset + 2 > len(data):
+            raise SidFormatError("SID dataOffset points past the end of the file")
+        real_load = data[data_offset] | (data[data_offset + 1] << 8)
+        data_start = data_offset + 2
+    else:
+        if data_offset > len(data):
+            raise SidFormatError("SID dataOffset points past the end of the file")
+        real_load = load_address
+        data_start = data_offset
+
+    return SidHeader(
+        magic=magic,
+        version=version,
+        data_offset=data_offset,
+        load_address=load_address,
+        init_address=init_address,
+        play_address=play_address,
+        songs=songs,
+        start_song=start_song,
+        name=name,
+        author=author,
+        released=released,
+        flags=flags,
+        second_sid=second_sid,
+        third_sid=third_sid,
+        real_load_address=real_load,
+        data_start=data_start,
+    )

pysidtracker/image.py

@@ -0,0 +1,128 @@
+"""The loaded C64 memory image a parser works against.
+
+:class:`SidImage` unwraps a PSID/RSID container (or a bare ``.prg``) into a full
+64 KiB memory image with the tune placed at its load address, plus absolute-
+addressed read accessors. This is the shared substitute for the per-parser
+``_Image`` / ``load_sid`` / ``_memory_accessors`` helpers.
+"""
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+from . import _scan
+from .errors import SidParseError
+from .header import SidHeader, parse_sid_header
+
+MEM_SIZE = 0x10000
+
+
+class SidImage:
+    """A 64 KiB C64 memory image with the tune loaded at its load address.
+
+    Attributes:
+      mem: ``bytearray`` of length ``0x10000`` (the C64 address space).
+      load: C64 address the image data starts at.
+      end: one past the last loaded byte (``0x10000`` after an init run, which
+        may have scattered data across memory).
+      header: the parsed :class:`SidHeader`, or ``None`` for a bare ``.prg``.
+      image: the raw C64 image bytes (player + data, without the container).
+      container: the container bytes preceding ``image`` (PSID/RSID header plus
+        any embedded 2-byte load address, or the ``.prg`` load-address prefix),
+        kept so a writer can re-emit a byte-identical container.
+    """
+
+    __slots__ = ("mem", "load", "end", "header", "image", "container")
+
+    def __init__(
+        self,
+        mem: bytearray,
+        load: int,
+        end: int,
+        header: Optional[SidHeader],
+        image: bytes,
+        container: bytes,
+    ):
+        self.mem = mem
+        self.load = load
+        self.end = end
+        self.header = header
+        self.image = image
+        self.container = container
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> "SidImage":
+        """Load a PSID/RSID ``.sid`` or a bare ``.prg`` image from ``data``."""
+        if data[:4] in (b"PSID", b"RSID"):
+            return cls.from_sid(data)
+        return cls.from_prg(data)
+
+    @classmethod
+    def from_sid(cls, data: bytes) -> "SidImage":
+        """Load a PSID/RSID container into a 64 KiB image."""
+        header = parse_sid_header(data)
+        image = bytes(data[header.data_start :])
+        container = bytes(data[: header.data_start])
+        load = header.real_load_address
+        return cls._place(image, load, header, container)
+
+    @classmethod
+    def from_prg(cls, data: bytes) -> "SidImage":
+        """Load a bare ``.prg`` (2-byte little-endian load address + image)."""
+        if len(data) < 2:
+            raise SidParseError("PRG too short for a load address")
+        load = data[0] | (data[1] << 8)
+        return cls._place(bytes(data[2:]), load, None, bytes(data[:2]))
+
+    @classmethod
+    def _place(cls, image: bytes, load: int, header, container) -> "SidImage":
+        end = load + len(image)
+        if end > MEM_SIZE:
+            raise SidParseError(
+                f"data overruns memory (load {load:#06x}, {len(image)} bytes)"
+            )
+        mem = bytearray(MEM_SIZE)
+        mem[load:end] = image
+        return cls(mem, load, end, header, image, container)
+
+    def byte(self, addr: int) -> int:
+        """Read one byte at C64 ``addr`` (raises out of ``0..0xFFFF``)."""
+        if not 0 <= addr < MEM_SIZE:
+            raise SidParseError(f"address {addr:#06x} out of range")
+        return self.mem[addr]
+
+    def peek(self, addr: int, default: int = 0) -> int:
+        """Read one byte at ``addr``, returning ``default`` if out of range."""
+        if 0 <= addr < MEM_SIZE:
+            return self.mem[addr]
+        return default
+
+    def word(self, addr: int) -> int:
+        """Read a little-endian 16-bit word at C64 ``addr``."""
+        return self.byte(addr) | (self.byte(addr + 1) << 8)
+
+    def slice(self, addr: int, length: int) -> bytes:
+        """Read ``length`` bytes starting at C64 ``addr`` (bounds-checked)."""
+        if addr < 0 or addr + length > MEM_SIZE:
+            raise SidParseError(f"slice at {addr:#06x}+{length} out of range")
+        return bytes(self.mem[addr : addr + length])
+
+    def ptr(self, lo_base: int, hi_base: int, index: int) -> int:
+        """Read a split-pointer-table entry (``lo[index]`` + ``hi[index]<<8``)."""
+        return self.peek(lo_base + index) | (self.peek(hi_base + index) << 8)
+
+    def find(self, needle: bytes, start: Optional[int] = None) -> int:
+        """First address of ``needle`` in the image, or ``-1``.
+
+        Search starts at ``start`` (defaulting to the load address, so the
+        container header is skipped).
+        """
+        return _scan.find_first(self.mem, needle, self.load if start is None else start)
+
+    def find_all(self, needle: bytes, start: Optional[int] = None) -> List[int]:
+        """Every address of ``needle`` in the image at or after ``start``."""
+        return _scan.find_all(self.mem, needle, self.load if start is None else start)
+
+    def find_split_table(self, lo, hi, *, min_length: int = 8) -> Optional[tuple]:
+        """Locate a split lo/hi table anchor (see :func:`_scan.find_split_table`)."""
+        return _scan.find_split_table(self.mem, lo, hi, min_length=min_length)

pysidtracker/source.py

@@ -0,0 +1,31 @@
+"""Normalise the many ways a caller can hand a tune to a parser.
+
+Every parser in the family accepts a path, a ``bytes`` blob, or an open binary
+file. :func:`read_bytes` is the single dispatch they share so ``read(...)``
+behaves identically everywhere.
+"""
+
+from __future__ import annotations
+
+import io
+import os
+from pathlib import Path
+from typing import Union
+
+Source = Union[bytes, bytearray, str, "os.PathLike[str]", io.IOBase]
+
+
+def read_bytes(src: Source) -> bytes:
+    """Return the raw bytes of ``src``.
+
+    ``src`` may be ``bytes``/``bytearray``, a filesystem path (``str`` or
+    :class:`os.PathLike`), or a binary file-like object with a ``read`` method.
+    Raises :class:`TypeError` for anything else.
+    """
+    if isinstance(src, (bytes, bytearray)):
+        return bytes(src)
+    if isinstance(src, (str, os.PathLike)):
+        return Path(src).read_bytes()
+    if isinstance(src, io.IOBase) or hasattr(src, "read"):
+        return src.read()
+    raise TypeError(f"cannot read a tune from {type(src).__name__}")

pysidtracker-0.1.0.dist-info/METADATA

@@ -0,0 +1,290 @@
+Metadata-Version: 2.4
+Name: pysidtracker
+Version: 0.1.0
+Summary: Shared base for pure-Python C64 SID tracker parsers: PSID/RSID container, loaded-image model, and packed/relocating playroutine detection
+Author: Josh Bailey
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship, whether in Source or
+              Object form, made available under the License, as indicated by a
+              copyright notice that is included in or attached to the work
+              (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean any work of authorship, including
+              the original version of the Work and any modifications or additions
+              to that Work or Derivative Works thereof, that is intentionally
+              submitted to Licensor for inclusion in the Work by the copyright owner
+              or by an individual or Legal Entity authorized to submit on behalf of
+              the copyright owner. For the purposes of this definition, "submitted"
+              means any form of electronic, verbal, or written communication sent
+              to the Licensor or its representatives, including but not limited to
+              communication on electronic mailing lists, source code control systems,
+              and issue tracking systems that are managed by, or on behalf of, the
+              Licensor for the purpose of discussing and improving the Work, but
+              excluding communication that is conspicuously marked or otherwise
+              designated in writing by the copyright owner as "Not a Contribution."
+        
+              "Contributor" shall mean Licensor and any individual or Legal Entity
+              on behalf of whom a Contribution has been received by Licensor and
+              subsequently incorporated within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a
+              cross-claim or counterclaim in a lawsuit) alleging that the Work
+              or a Contribution incorporated within the Work constitutes direct
+              or contributory patent infringement, then any patent licenses
+              granted to You under this License for that Work shall terminate
+              as of the date such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or
+                  Derivative Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, then any Derivative Works that You distribute must
+                  include a readable copy of the attribution notices contained
+                  within such NOTICE file, excluding those notices that do not
+                  pertain to any part of the Derivative Works, in at least one
+                  of the following places: within a NOTICE text file distributed
+                  as part of the Derivative Works; within the Source form or
+                  documentation, if provided along with the Derivative Works; or,
+                  within a display generated by the Derivative Works, if and
+                  wherever such third-party notices normally appear. The contents
+                  of the NOTICE file are for informational purposes only and
+                  do not modify the License. You may add Your own attribution
+                  notices within Derivative Works that You distribute, alongside
+                  or as an addendum to the NOTICE text from the Work, provided
+                  that such additional attribution notices cannot be construed
+                  as modifying the License.
+        
+              You may add Your own copyright statement to Your modifications and
+              may provide additional or different license terms and conditions
+              for use, reproduction, or distribution of Your modifications, or
+              for any such Derivative Works as a whole, provided Your use,
+              reproduction, and distribution of the Work otherwise complies with
+              the conditions stated in this License.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or redistributing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or consequential damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or any and all
+              other commercial damages or losses), even if such Contributor
+              has been advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Additional Liability. While redistributing
+              the Work or Derivative Works thereof, You may choose to offer,
+              and charge a fee for, acceptance of support, warranty, indemnity,
+              or other liability obligations and/or rights consistent with this
+              License. However, in accepting such obligations, You may act only
+              on Your own behalf and on Your sole responsibility, not on behalf
+              of any other Contributor, and only if You agree to indemnify,
+              defend, and hold each Contributor harmless for any liability
+              incurred by, or claims asserted against, such Contributor by reason
+              of your accepting any such warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+           APPENDIX: How to apply the Apache License to your work.
+        
+              To apply the Apache License to your work, attach the following
+              boilerplate notice, with the fields enclosed by brackets "[]"
+              replaced with your own identifying information. (Don't include
+              the brackets!)  The text should be enclosed in the appropriate
+              comment syntax for the file format. We also recommend that a
+              file or class name and description of purpose be included on the
+              same "printed page" as the copyright notice for easier
+              identification within third-party archives.
+        
+           Copyright [yyyy] [name of copyright owner]
+        
+           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.
+        
+Project-URL: Homepage, https://github.com/anarkiwi/pysidtracker
+Project-URL: Source, https://github.com/anarkiwi/pysidtracker
+Project-URL: Issues, https://github.com/anarkiwi/pysidtracker/issues
+Keywords: sid,c64,psid,rsid,tracker,chiptune
+Classifier: License :: OSI Approved :: Apache Software 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: Topic :: Multimedia :: Sound/Audio
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: emu
+Requires-Dist: py65>=1.1; extra == "emu"
+Provides-Extra: fast
+Requires-Dist: numpy>=1.23; extra == "fast"
+Provides-Extra: dev
+Requires-Dist: black>=24; extra == "dev"
+Requires-Dist: numpy>=1.23; extra == "dev"
+Requires-Dist: py65>=1.1; extra == "dev"
+Requires-Dist: pylint>=3; extra == "dev"
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-cov>=4; extra == "dev"
+Requires-Dist: pytest-xdist>=3; extra == "dev"
+Dynamic: license-file
+
+# pysidtracker
+
+Shared base for the pure-Python C64 SID tracker parsers (pygoattracker,
+pysidwizard, pydmcsid, pyfuturecomposer, pymusicassembler, pydefmon, pyjch).
+
+Provides one implementation of the pieces every format parser duplicated:
+
+- **`parse_sid_header` / `SidHeader`** — PSID/RSID container header parsing.
+- **`SidImage`** — a loaded 64 KiB C64 memory image with absolute-addressed
+  accessors, from a `.sid` container or a bare `.prg`.
+- **`read_bytes`** — path / `bytes` / file-like source dispatch.
+- **`SidError` hierarchy** — `SidParseError`, `SidFormatError`,
+  `EmulatorUnavailable`.
+- **`detect_playroutine` / `PlayroutineKind`** — the untrustworthy-header
+  detector: static signature recognition first, then an emulated init run to
+  classify `DIRECT` / `RELOCATED` / `PACKED` / `UNKNOWN` playroutines.
+- **`BaseSidParser`** — the class each format subclasses for a consistent
+  `read` / `parse` / `detect` API.
+
+## Install
+
+```
+pip install pysidtracker          # core (stdlib only)
+pip install pysidtracker[emu]     # + py65, to unpack packed/relocating tunes
+pip install pysidtracker[fast]    # + numpy, to accelerate the image scan
+```
+
+## Usage
+
+```python
+from pysidtracker import BaseSidParser, PlayroutineKind
+
+class MyParser(BaseSidParser):
+    def recognize(self, image):
+        return image.find(b"MYSIG")          # truthy anchor when found
+    def parse(self, data, **kw):
+        image = self.load_image(data)
+        ...                                    # decode image.mem into a model
+
+det = MyParser().detect("tune.sid")
+if det.kind is PlayroutineKind.PACKED:
+    ...                                        # header was not trustworthy
+```
+
+See [docs/design.md](docs/design.md) for the detection model and how the
+format packages consume this base.
+
+## Development
+
+```
+pip install -e ".[dev]"
+pytest --cov=pysidtracker
+```
+
+Apache-2.0 licensed.

pysidtracker-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+pysidtracker/__init__.py,sha256=Dt_ZWgzlgs8DAMCkteuPEhWDYF3-iKNRxS8Rt42bLaU,1182
+pysidtracker/_scan.py,sha256=PRywY8_NkxfRz89yyiwooC7LCJS8_jH4uwxgUuoHG84,4213
+pysidtracker/base.py,sha256=cl1NaGaSHGqoMbupz6wLNnrsZhD32DN4tAKMODKGuhg,2708
+pysidtracker/detect.py,sha256=qAcdQ_xIBDf9kOJI6qCdlwwFF1IoBcAPXVCB0ATZftY,6785
+pysidtracker/errors.py,sha256=J4Jk8ADpVG-LK7AkbR44E9IxcwCK9N-zgZ6jz0gA7rw,950
+pysidtracker/header.py,sha256=Up4EGKTZG9iagB5PTRhEJWA-XXjOZyPF0bVNOoQHoYg,5025
+pysidtracker/image.py,sha256=xBzYbIPeQwbgKFxvXScA0uRPjPpT9a5vqjzEAEW8rCI,5139
+pysidtracker/source.py,sha256=CdES1CaNdce6i3f-iUQjNsy_mmcUw6YRRWjx2lShLoI,1032
+pysidtracker-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pysidtracker-0.1.0.dist-info/METADATA,sha256=m0OJcS3qc86leEV668os7opcqB-Ir5908GCabF9WLKk,16253
+pysidtracker-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+pysidtracker-0.1.0.dist-info/top_level.txt,sha256=z2aVHwZ83jWSRKUY8ziwjK8_-itI4c6MMuLoqgE88tE,13
+pysidtracker-0.1.0.dist-info/RECORD,,

pysidtracker-0.1.0.dist-info/WHEEL

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

pysidtracker-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

pysidtracker-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pysidtracker