tasd 1.0.0__py3-none-any.whl

tasd/__init__.py

@@ -0,0 +1,4 @@
+from tasd.file import TASD
+import tasd.packets
+import tasd.constants
+import tasd.utils

tasd/constants.py

@@ -0,0 +1,56 @@
+class _MetaPacketType():
+    def __init_subclass__(self):
+        keys = [key for key in self.__dict__.keys() if type(self.__dict__[key]) == int]
+        self._key2name = dict()
+        for key in keys:
+            self._key2name[self.__dict__[key]] = key
+
+class PacketType(_MetaPacketType):
+    # General Keys
+    CONSOLE_TYPE                = 0x0001
+    CONSOLE_REGION              = 0x0002
+    GAME_TITLE                  = 0x0003
+    ROM_NAME                    = 0x0004
+    ATTRIBUTION                 = 0x0005
+    CATEGORY                    = 0x0006
+    EMULATOR_NAME               = 0x0007
+    EMULATOR_VERSION            = 0x0008
+    EMULATOR_CORE               = 0x0009
+    TAS_LAST_MODIFIED           = 0x000A
+    DUMP_CREATED                = 0x000B
+    DUMP_LAST_MODIFIED          = 0x000C
+    TOTAL_FRAMES                = 0x000D
+    RERECORDS                   = 0x000E
+    SOURCE_LINK                 = 0x000F
+    BLANK_FRAMES                = 0x0010
+    VERIFIED                    = 0x0011
+    MEMORY_INIT                 = 0x0012
+    GAME_IDENTIFIER             = 0x0013
+    MOVIE_LICENSE               = 0x0014
+    MOVIE_FILE                  = 0x0015
+    PORT_CONTROLLER             = 0x00F0
+    PORT_OVERREAD               = 0x00F1
+    # NES Specific Keys
+    NES_LATCH_FILTER            = 0x0101
+    NES_CLOCK_FILTER            = 0x0102
+    NES_GAME_GENIE_CODE         = 0x0104
+    # SNES Specific Keys
+    SNES_LATCH_FILTER           = 0x0201
+    SNES_CLOCK_FILTER           = 0x0202
+    SNES_GAME_GENIE_CODE        = 0x0204
+    SNES_LATCH_TRAIN            = 0x0205
+    # Genesis Specific Keys
+    GENESIS_GAME_GENIE_CODE     = 0x0804
+    # Input Frame/Timing Keys
+    INPUT_CHUNK                 = 0xFE01
+    INPUT_MOMENT                = 0xFE02
+    TRANSITION                  = 0xFE03
+    LAG_FRAME_CHUNK             = 0xFE04
+    MOVIE_TRANSITION            = 0xFE05
+    # Extraneous Keys
+    COMMENT                     = 0xFF01
+    EXPERIMENTAL                = 0xFFFE
+    UNSPECIFIED                 = 0xFFFF
+    @classmethod
+    def lookup(cls, key):
+        return cls._key2name.get(key, f'UNKNOWN_PACKET_{key:04X}')

tasd/file.py

@@ -0,0 +1,57 @@
+import tasd.packets as packets
+import tasd.constants as constants
+import tasd.utils as utils
+from tasd.packet import lookup_packet, _TASDPacket
+from typing import List
+
+class TASD():
+    MAGIC = b"TASD"
+    def __init__(self, version = 1, g_keylen = 2):
+        self.version = version
+        self.g_keylen = g_keylen
+        self.packets: List[_TASDPacket] = []
+    @classmethod
+    def from_bytes(cls, buffer: bytes, *, bypass_errors = False):
+        magic = utils.readBytes(buffer, 0, 4)
+        if magic != cls.MAGIC:
+            raise ValueError("Invalid TASD File, Missing Magic")
+        version = utils.readUint16(buffer, 4)
+        if version != 1 and not bypass_errors:
+            raise ValueError("Unsupported TASD File, Version Unsupported", version)
+        g_keylen = utils.readUint8(buffer, 6)
+        if g_keylen != 2:
+            raise ValueError("Unsupported TASD File, Unknown G_KEYLEN", g_keylen)
+        self = cls(version, g_keylen)
+        index = 7
+        while index < len(buffer):
+            key = utils.readUintN(buffer, index, self.g_keylen)
+            index += self.g_keylen
+            packet_cls = lookup_packet(key)
+            pexp = utils.readUint8(buffer, index)
+            index += 1
+            plen = utils.readUintN(buffer, index, pexp)
+            index += pexp
+            data = utils.readBytes(buffer, index, plen)
+            index += plen
+            packet = packet_cls.from_bytes(data)
+            self.packets.append(packet)
+        return self
+    def to_bytes(self):
+        header = bytearray(7)
+        header[0:4] = self.MAGIC
+        utils.writeUint16(self.version, header, 4)
+        utils.writeUint8(self.g_keylen, header, 6)
+        packets = [ header ]
+        for packet in self.packets:
+            plen = packet.size()
+            pexp = utils.minUint(plen)
+            size = self.g_keylen + 1 + pexp
+            buffer = bytearray(size)
+            utils.writeUintN(packet._key, buffer, 0, self.g_keylen)
+            utils.writeUint8(pexp, buffer, self.g_keylen)
+            utils.writeUintN(plen, buffer, self.g_keylen + 1, pexp)
+            payload = packet.to_bytes()
+            packets.append(buffer + payload)
+        return b"".join(packets)
+    def __repr__(self):
+        return f"TASD(version={self.version}, g_keylen={self.g_keylen})"

tasd/packet.py

@@ -0,0 +1,304 @@
+from typing import NamedTuple, List, Any
+from enum import Enum
+
+from tasd.constants import PacketType
+from tasd.utils import *
+
+class _VariableType(Enum):
+    STRING_EOP     = 0x00
+    STRING_PLEN    = 0x01
+    STRING_PEXP    = 0x02
+    BYTES_EOP      = 0x10
+    BYTES_PLEN     = 0x11
+    BYTES_PEXP     = 0x12
+    INT_8          = 0x20
+    INT_16         = 0x21
+    INT_24         = 0x22
+    INT_32         = 0x23
+    INT_64         = 0x24
+    INT_N          = 0x25
+    UINT_8         = 0x30
+    UINT_16        = 0x31
+    UINT_24        = 0x32
+    UINT_32        = 0x33
+    UINT_64        = 0x34
+    UINT_N         = 0x35
+    BOOL           = 0x40
+    LIST_UINT_64   = 0x50
+
+
+class _VariableDefinition(NamedTuple):
+    name: str
+    type: _VariableType
+    default: Any
+
+class _EnumDefinition(NamedTuple):
+    name: str
+    enum: Enum
+
+class _TASDPacket():
+    @classmethod
+    def from_bytes(cls, buffer: bytes):
+        self = cls()
+        index = 0
+        for variable in cls._variables:
+            match variable.type:
+                case _VariableType.STRING_EOP:
+                    setattr(self, variable.name, readString(buffer, index, len(buffer) - index))
+                    index = len(buffer)
+                case _VariableType.STRING_PLEN:
+                    plen = readInt8(buffer, index)
+                    index += 1
+                    setattr(self, variable.name, readString(buffer, index, plen))
+                    index += plen
+                case _VariableType.STRING_PEXP:
+                    pexp = readInt8(buffer, index)
+                    index += 1
+                    plen = readIntN(buffer, index, pexp)
+                    index += pexp
+                    setattr(self, variable.name, readString(buffer, index, plen))
+                    index += plen
+                case _VariableType.BYTES_EOP:
+                    setattr(self, variable.name, readBytes(buffer, index, len(buffer)))
+                    index = len(buffer)
+                case _VariableType.BYTES_PLEN:
+                    plen = readInt8(buffer, index)
+                    index += 1
+                    setattr(self, variable.name, readBytes(buffer, index, plen))
+                    index += plen
+                case _VariableType.BYTES_PEXP:
+                    pexp = readInt8(buffer, index)
+                    index += 1
+                    plen = readIntN(buffer, index, pexp)
+                    index += pexp
+                    setattr(self, variable.name, readBytes(buffer, index, plen))
+                    index += plen
+                case _VariableType.INT_8:
+                    setattr(self, variable.name, readInt8(buffer, index))
+                    index += 1
+                case _VariableType.INT_16:
+                    setattr(self, variable.name, readInt16(buffer, index))
+                    index += 2
+                case _VariableType.INT_24:
+                    setattr(self, variable.name, readInt24(buffer, index))
+                    index += 3
+                case _VariableType.INT_32:
+                    setattr(self, variable.name, readInt32(buffer, index))
+                    index += 4
+                case _VariableType.INT_64:
+                    setattr(self, variable.name, readInt64(buffer, index))
+                    index += 8
+                case _VariableType.INT_N:
+                    pexp = readInt8(buffer, index)
+                    index += 1
+                    setattr(self, variable.name, readIntN(buffer, index, pexp))
+                    index += pexp
+                case _VariableType.UINT_8:
+                    setattr(self, variable.name, readUint8(buffer, index))
+                    index += 1
+                case _VariableType.UINT_16:
+                    setattr(self, variable.name, readUint16(buffer, index))
+                    index += 2
+                case _VariableType.UINT_24:
+                    setattr(self, variable.name, readUint24(buffer, index))
+                    index += 3
+                case _VariableType.UINT_32:
+                    setattr(self, variable.name, readUint32(buffer, index))
+                    index += 4
+                case _VariableType.UINT_64:
+                    setattr(self, variable.name, readUint64(buffer, index))
+                    index += 8
+                case _VariableType.UINT_N:
+                    pexp = readUint8(buffer, index)
+                    index += 1
+                    setattr(self, variable.name, readUintN(buffer, index, pexp))
+                    index += pexp
+                case _VariableType.BOOL:
+                    setattr(self, variable.name, readBoolean(buffer, index))
+                    index += 1
+                case _VariableType.LIST_UINT_64:
+                    l = list()
+                    while index < len(buffer):
+                        l.append(readUint64(buffer, index))
+                        index += 8
+                    setattr(self, variable.name, l)
+                case _:
+                    raise ValueError("Unknown Variable Type", variable)
+        return self
+    def size(self):
+        size = 0
+        for variable in self._variables:
+            value = getattr(self, variable.name)
+            match variable.type:
+                case _VariableType.STRING_EOP:
+                    size += sizeString(value)
+                case _VariableType.STRING_PLEN:
+                    size += ( 1 + sizeString(value) )
+                case _VariableType.STRING_PEXP:
+                    vsize = sizeString(value)
+                    size += ( 1 + minUint(vsize) + vsize )
+                case _VariableType.BYTES_EOP:
+                    size += len(value)
+                case _VariableType.BYTES_PLEN:
+                    size += ( 1 + len(value) )
+                case _VariableType.BYTES_PEXP:
+                    vsize = len(value)
+                    size += ( 1 + minUint(vsize) + vsize )
+                case _VariableType.INT_8:
+                    size += 1
+                case _VariableType.INT_16:
+                    size += 2
+                case _VariableType.INT_24:
+                    size += 3
+                case _VariableType.INT_32:
+                    size += 4
+                case _VariableType.INT_64:
+                    size += 8
+                case _VariableType.INT_N:
+                    size += minInt(value)
+                case _VariableType.UINT_8:
+                    size += 1
+                case _VariableType.UINT_16:
+                    size += 2
+                case _VariableType.UINT_24:
+                    size += 3
+                case _VariableType.UINT_32:
+                    size += 4
+                case _VariableType.UINT_64:
+                    size += 8
+                case _VariableType.UINT_N:
+                    size += minUint(value)
+                case _VariableType.BOOL:
+                    size += 1
+                case _VariableType.LIST_UINT_64:
+                    size += ( 8 * len(value) )
+                case _:
+                    raise ValueError("Unknown Variable Type", variable)
+        return size
+    def to_bytes(self):
+        buffer = bytearray(self.size())
+        index = 0
+        for variable in self._variables:
+            value = getattr(self, variable.name)
+            match variable.type:
+                case _VariableType.STRING_EOP:
+                    writeString(value, buffer, index)
+                    index += sizeString(value)
+                case _VariableType.STRING_PLEN:
+                    plen = sizeString(value)
+                    writeUint8(plen, buffer, index)
+                    index += 1
+                    writeString(value, buffer, index)
+                    index += plen
+                case _VariableType.STRING_PEXP:
+                    plen = sizeString(value)
+                    pexp = minUint(plen)
+                    writeUint8(pexp, buffer, index)
+                    index += 1
+                    writeUintN(plen, buffer, index, pexp)
+                    index += pexp
+                    writeString(value, buffer, index)
+                    index += plen
+                case _VariableType.BYTES_EOP:
+                    writeBytes(value, buffer, index)
+                    index += len(value)
+                case _VariableType.BYTES_PLEN:
+                    plen = len(value)
+                    writeUint8(plen, buffer, index)
+                    index += 1
+                    writeBytes(value, buffer, index)
+                    index += plen
+                case _VariableType.BYTES_PEXP:
+                    plen = len(value)
+                    pexp = minUint(plen)
+                    writeUint8(pexp, buffer, index)
+                    index += 1
+                    writeUintN(plen, buffer, index, pexp)
+                    index += pexp
+                    writeBytes(value, buffer, index)
+                    index += plen
+                case _VariableType.INT_8:
+                    writeInt8(value, buffer, index)
+                    index += 1
+                case _VariableType.INT_16:
+                    writeInt16(value, buffer, index)
+                    index += 2
+                case _VariableType.INT_24:
+                    writeInt24(value, buffer, index)
+                    index += 3
+                case _VariableType.INT_32:
+                    writeInt32(value, buffer, index)
+                    index += 4
+                case _VariableType.INT_64:
+                    writeInt64(value, buffer, index)
+                    index += 8
+                case _VariableType.INT_N:
+                    pexp = minInt(value)
+                    writeUint8(pexp, buffer, index)
+                    index += 1
+                    writeIntN(value, buffer, index, pexp)
+                    index += pexp
+                case _VariableType.UINT_8:
+                    writeUint8(value, buffer, index)
+                    index += 1
+                case _VariableType.UINT_16:
+                    writeUint16(value, buffer, index)
+                    index += 2
+                case _VariableType.UINT_24:
+                    writeUint24(value, buffer, index)
+                    index += 3
+                case _VariableType.UINT_32:
+                    writeUint32(value, buffer, index)
+                    index += 4
+                case _VariableType.UINT_64:
+                    writeUint64(value, buffer, index)
+                    index += 8
+                case _VariableType.UINT_N:
+                    pexp = minInt(value)
+                    writeUint8(pexp, buffer, index)
+                    index += 1
+                    writeUintN(value, buffer, index, pexp)
+                    index += pexp
+                case _VariableType.BOOL:
+                    writeBoolean(value, buffer, index)
+                    index += 1
+                case _VariableType.LIST_UINT_64:
+                    for val in value:
+                        writeUint64(val, buffer, index)
+                        index += 8
+                case _:
+                    raise ValueError("Unknown Variable Type", variable)
+        return buffer
+    def __repr__(self):
+        return f"{self._name}({', '.join(f'{var.name}={getattr(self, var.name)}' for var in self._variables)})"
+
+_lookup_table = dict()
+
+def _TASDPacketFactory(name: str, key: int, variables: List[_VariableDefinition] = [], enums: List[_EnumDefinition] = []):
+    class Packet(_TASDPacket):
+        _variables = variables
+        _key = key
+        _name = name
+        def __init__(self, **kwargs):
+            for variable in Packet._variables:
+                setattr(self, variable.name, kwargs.get(variable.name, variable.default))
+
+    for enum in enums:
+        setattr(Packet, enum.name, enum.enum)
+
+    _lookup_table[key] = Packet
+
+    Packet.__name__ = name
+    Packet.__qualname__ = name
+    return Packet
+
+def _build_unknown_packet(key):
+    _UnknownPacket = _TASDPacketFactory(f"UnknownPacket_{key:04x}", key, [ _VariableDefinition("data", _VariableType.BYTES_EOP, b"") ])
+    return _UnknownPacket
+
+def lookup_packet(key: int) -> _TASDPacket:
+    packet = _lookup_table.get(key, None)
+    if packet == None:
+        packet = _build_unknown_packet(key)
+    return packet
+    

tasd/packets/__init__.py

@@ -0,0 +1,6 @@
+import tasd.packets.general
+import tasd.packets.nes
+import tasd.packets.snes
+import tasd.packets.genesis
+import tasd.packets.input
+import tasd.packets.extra

tasd/packets/extra.py

@@ -0,0 +1,38 @@
+from tasd.packet import _TASDPacketFactory as _TASD_PF, _VariableType as _VType, _VariableDefinition as _VDef, _EnumDefinition as _EDef
+from tasd.constants import PacketType
+
+'''
+ 4.3.6.1. COMMENT Packet
+'''
+
+Comment = _TASD_PF(
+    "Comment",
+    PacketType.COMMENT,
+    [
+        _VDef("comment", _VType.STRING_EOP, "")
+    ]
+)
+
+'''
+ 4.3.6.2. EXPERIMENTAL Packet
+'''
+
+Experimental = _TASD_PF(
+    "Experimental",
+    PacketType.EXPERIMENTAL,
+    [
+        _VDef("experimental", _VType.BOOL, False)
+    ]
+)
+
+'''
+ 4.3.6.3. UNSPECIFIED Packet
+'''
+
+Unspecified = _TASD_PF(
+    "Unspecified",
+    PacketType.UNSPECIFIED,
+    [
+        _VDef("data", _VType.BYTES_EOP, b"")
+    ]
+)

tasd/packets/general.py

@@ -0,0 +1,406 @@
+from tasd.packet import _TASDPacketFactory as _TASD_PF, _VariableType as _VType, _VariableDefinition as _VDef, _EnumDefinition as _EDef
+from tasd.constants import PacketType
+
+'''
+ 4.3.1.1. CONSOLE_TYPE Packet
+'''
+
+class CONSOLE_TYPE():
+    NES       = 0x01
+    SNES      = 0x02
+    N64       = 0x03
+    GC        = 0x04
+    GB        = 0x05
+    GBC       = 0x06
+    GBA       = 0x07
+    GENESIS   = 0x08
+    A2600     = 0x09
+    CUSTOM    = 0xFF
+ConsoleType = _TASD_PF(
+    "ConsoleType",
+    PacketType.CONSOLE_TYPE,
+    [
+        _VDef("console", _VType.UINT_8, CONSOLE_TYPE.NES),
+        _VDef("name", _VType.STRING_EOP, "")
+    ],
+    [
+        _EDef("CONSOLE_TYPE", CONSOLE_TYPE)
+    ]
+)
+
+'''
+ 4.3.1.2. CONSOLE_REGION Packet
+'''
+
+class CONSOLE_REGION():
+    NTSC    = 0x01
+    PAL     = 0x02
+    OTHER   = 0xFF
+ConsoleRegion = _TASD_PF(
+    "ConsoleRegion",
+    PacketType.CONSOLE_REGION,
+    [
+        _VDef("region", _VType.UINT_8, CONSOLE_REGION.NTSC)
+    ],
+    [
+        _EDef("CONSOLE_REGION", CONSOLE_REGION)
+    ]
+)
+
+'''
+ 4.3.1.3. GAME_TITLE Packet
+'''
+
+GameTitle = _TASD_PF(
+    "GameTitle",
+    PacketType.GAME_TITLE,
+    [
+        _VDef("title", _VType.STRING_EOP, "")
+    ]
+)
+
+
+'''
+ 4.3.1.4. ROM_NAME Packet
+'''
+
+RomName = _TASD_PF(
+    "RomName",
+    PacketType.ROM_NAME,
+    [
+        _VDef("name", _VType.STRING_EOP, "")
+    ]
+)
+
+'''
+ 4.3.1.5. ATTRIBUTION Packet
+'''
+
+class ATTRIBUTION_TYPE():
+    AUTHOR              = 0x01
+    VERIFIER            = 0x02
+    TASD_FILE_CREATOR   = 0x03
+    TASD_FILE_EDITOR    = 0x04
+    OTHER               = 0xFF
+Attribution = _TASD_PF(
+    "Attribution",
+    PacketType.ATTRIBUTION,
+    [
+        _VDef("type", _VType.UINT_8, ATTRIBUTION_TYPE.AUTHOR),
+        _VDef("name", _VType.STRING_EOP, "")
+    ],
+    [
+        _EDef("ATTRIBUTION_TYPE", ATTRIBUTION_TYPE)
+    ]
+)
+
+
+'''
+ 4.3.1.6. CATEGORY Packet
+'''
+
+Category = _TASD_PF(
+    "Category",
+    PacketType.CATEGORY,
+    [
+        _VDef("category", _VType.STRING_EOP, "")
+    ]
+)
+
+'''
+ 4.3.1.7. EMULATOR_NAME Packet
+'''
+
+EmulatorName = _TASD_PF(
+    "EmulatorName",
+    PacketType.EMULATOR_NAME,
+    [
+        _VDef("name", _VType.STRING_EOP, "")
+    ]
+)
+
+'''
+ 4.3.1.8. EMULATOR_VERSION Packet
+'''
+
+EmulatorVersion = _TASD_PF(
+    "EmulatorVersion",
+    PacketType.EMULATOR_VERSION,
+    [
+        _VDef("version", _VType.STRING_EOP, "")
+    ]
+)
+
+'''
+ 4.3.1.9. EMULATOR_CORE Packet
+'''
+
+EmulatorCore = _TASD_PF(
+    "EmulatorCore",
+    PacketType.EMULATOR_CORE,
+    [
+        _VDef("core", _VType.STRING_EOP, "")
+    ]
+)
+
+'''
+ 4.3.1.10. TAS_LAST_MODIFIED Packet
+'''
+
+TASLastModified = _TASD_PF(
+    "TASLastModified",
+    PacketType.TAS_LAST_MODIFIED,
+    [
+        _VDef("timestamp", _VType.INT_64, 0)
+    ]
+)
+
+'''
+ 4.3.1.11. DUMP_CREATED Packet
+'''
+
+DumpCreated = _TASD_PF(
+    "DumpCreated",
+    PacketType.DUMP_CREATED,
+    [
+        _VDef("timestamp", _VType.INT_64, 0)
+    ]
+)
+
+'''
+ 4.3.1.12. DUMP_LAST_MODIFIED Packet
+'''
+
+DumpLastModified = _TASD_PF(
+    "DumpLastModified",
+    PacketType.DUMP_LAST_MODIFIED,
+    [
+        _VDef("timestamp", _VType.INT_64, 0)
+    ]
+)
+
+'''
+ 4.3.1.13. TOTAL_FRAMES Packet
+'''
+
+TotalFrames = _TASD_PF(
+    "TotalFrames",
+    PacketType.TOTAL_FRAMES,
+    [
+        _VDef("frames", _VType.UINT_32, 0)
+    ]
+)
+
+'''
+ 4.3.1.14. RERECORDS Packet
+'''
+
+Rerecords = _TASD_PF(
+    "Rerecords",
+    PacketType.RERECORDS,
+    [
+        _VDef("rerecords", _VType.UINT_32, 0)
+    ]
+)
+
+'''
+ 4.3.1.15. SOURCE_LINK Packet
+'''
+
+SourceLink = _TASD_PF(
+    "SourceLink",
+    PacketType.SOURCE_LINK,
+    [
+        _VDef("link", _VType.STRING_EOP, "")
+    ]
+)
+
+'''
+ 4.3.1.16. BLANK_FRAMES Packet
+'''
+
+BlankFrames = _TASD_PF(
+    "BlankFrames",
+    PacketType.BLANK_FRAMES,
+    [
+        _VDef("frames", _VType.INT_16, 0)
+    ]
+)
+
+'''
+ 4.3.1.17. VERIFIED Packet
+'''
+
+Verified = _TASD_PF(
+    "Verified",
+    PacketType.VERIFIED,
+    [
+        _VDef("verified", _VType.BOOL, False)
+    ]
+)
+
+'''
+ 4.3.1.18. MEMORY_INIT Packet
+'''
+
+class MEMORY_INIT_TYPE():
+    NONE                       = 0x01
+    ALL_00                     = 0x02
+    ALL_FF                     = 0x03
+    PATTERN_00000000FFFFFFFF   = 0x04
+    RANDOM                     = 0x05
+    CUSTOM                     = 0xFF
+class MEMORY_INIT_DEVICE():
+    NES_CPU_RAM         = 0x0101
+    NES_CART_SRAM       = 0x0102
+    SNES_CPU_RAM        = 0x0201
+    SNES_CART_SRAM      = 0x0202
+    GB_CPU_RAM          = 0x0501
+    GB_CART_SRAM        = 0x0502
+    GBC_CPU_RAM         = 0x0601
+    GBC_CART_SRAM       = 0x0602
+    GBA_CPU_RAM         = 0x0701
+    GBA_CART_SRAM       = 0x0702
+    GENESIS_CPU_RAM     = 0x0801
+    GENESIS_CART_SRAM   = 0x0802
+    A2600_CPU_RAM       = 0x0901
+    A2600_CART_SRAM     = 0x0902
+    CUSTOM              = 0xFFFF
+MemoryInit = _TASD_PF(
+    "MemoryInit",
+    PacketType.MEMORY_INIT,
+    [
+        _VDef("type", _VType.UINT_8, MEMORY_INIT_TYPE.NONE),
+        _VDef("device", _VType.UINT_16, MEMORY_INIT_DEVICE.NES_CPU_RAM),
+        _VDef("required", _VType.BOOL, False),
+        _VDef("name", _VType.STRING_PLEN, ""),
+        _VDef("data", _VType.BYTES_EOP, b"")
+    ],
+    [
+        _EDef("MEMORY_INIT_TYPE", MEMORY_INIT_TYPE),
+        _EDef("MEMORY_INIT_DEVICE", MEMORY_INIT_DEVICE)
+    ]
+)
+
+'''
+ 4.3.1.19. GAME_IDENTIFIER Packet
+'''
+
+class GAME_IDENTIFIER_TYPE():
+    MD5          = 0x01
+    SHA1         = 0x02
+    SHA224       = 0x03
+    SHA256       = 0x04
+    SHA384       = 0x05
+    SHA512       = 0x06
+    SHA512_224   = 0x07
+    SHA512_256   = 0x08
+    SHA3_224     = 0x09
+    SHA3_256     = 0x0A
+    SHA3_384     = 0x0B
+    SHA3_512     = 0x0C
+    SHAKE_128    = 0x0D
+    SHAKE_256    = 0x0E
+    OTHER        = 0xFF
+class GAME_IDENTIFIER_BASE():
+    RAW_BINARY   = 0x01
+    BASE16       = 0x02
+    BASE32       = 0x03
+    BASE64       = 0x04
+    OTHER        = 0xFF
+GameIdentifier = _TASD_PF(
+    "GameIdentifier",
+    PacketType.GAME_IDENTIFIER,
+    [
+        _VDef("type", _VType.UINT_8, GAME_IDENTIFIER_TYPE.MD5),
+        _VDef("encoding", _VType.UINT_8, GAME_IDENTIFIER_BASE.RAW_BINARY),
+        _VDef("name", _VType.STRING_PLEN, ""),
+        _VDef("identifier", _VType.BYTES_EOP, b"")
+    ],
+    [
+        _EDef("GAME_IDENTIFIER_TYPE", GAME_IDENTIFIER_TYPE),
+        _EDef("GAME_IDENTIFIER_BASE", GAME_IDENTIFIER_BASE)
+    ])
+
+'''
+ 4.3.1.20. MOVIE_LICENSE Packet
+'''
+
+MovieLicense = _TASD_PF(
+    "MovieLicense",
+    PacketType.MOVIE_LICENSE,
+    [
+        _VDef("link", _VType.STRING_EOP, "")
+    ]
+)
+
+'''
+ 4.3.1.21. MOVIE_FILE Packet
+'''
+
+MovieFile = _TASD_PF(
+    "MovieFile",
+    PacketType.MOVIE_FILE,
+    [
+        _VDef("name", _VType.STRING_PLEN, ""),
+        _VDef("data", _VType.BYTES_EOP, b"")
+    ]
+)
+
+'''
+ 4.3.1.22. PORT_CONTROLLER Packet
+'''
+
+class CONTROLLER_TYPE():
+    NES_STANDARD_CONTROLLER                       = 0x0101
+    NES_FOUR_SCORE                                = 0x0102
+    NES_ZAPPER                                    = 0x0103
+    NES_POWER_PAD                                 = 0x0104
+    FAMICOM_FAMILY_BASIC_KEYBOARD                 = 0x0105
+    SNES_STANDARD_CONTROLLER                      = 0x0201
+    SNES_SUPER_MULTITAP                           = 0x0202
+    SNES_MOUSE                                    = 0x0203
+    SNES_SUPERSCOPE                               = 0x0204
+    N64_STANDARD_CONTROLLER                       = 0x0301
+    N64_STANDARD_CONTROLLER_WITH_RUMBLE_PAK       = 0x0302
+    N64_STANDARD_CONTROLLER_WITH_CONTROLLER_PAK   = 0x0303
+    N64_STANDARD_CONTROLLER_WITH_TRANSFER_PAK     = 0x0304
+    N64_MOUSE                                     = 0x0305
+    N64_VOICE_RECOGNITION_UNIT                    = 0x0306
+    N64_RANDNET_KEYBOARD                          = 0x0307
+    N64_DENSHA_DE_GO                              = 0x0308
+    GC_STANDARD_CONTROLLER                        = 0x0401
+    GC_KEYBOARD                                   = 0x0402
+    GB_GAMEPAD                                    = 0x0501
+    GBC_GAMEPAD                                   = 0x0601
+    GBA_GAMEPAD                                   = 0x0701
+    GENESIS_3BUTTON                               = 0x0801
+    GENESIS_6BUTTON                               = 0x0802
+    A2600_JOYSTICK                                = 0x0901
+    A2600_PADDLE                                  = 0x0902
+    A2600_KEYBOARD_CONTROLLER                     = 0x0903
+    OTHER_UNSPECIFIED                             = 0xFFFF
+PortController = _TASD_PF(
+    "PortController",
+    PacketType.PORT_CONTROLLER,
+    [
+        _VDef("port", _VType.UINT_8, 1),
+        _VDef("type", _VType.UINT_16, CONTROLLER_TYPE.NES_STANDARD_CONTROLLER)
+    ],
+    [
+        _EDef("CONTROLLER_TYPE", CONTROLLER_TYPE)
+    ]
+)
+
+'''
+ 4.3.1.23. PORT_OVERREAD Packet
+'''
+
+PortOverread = _TASD_PF(
+    "PortOverread",
+    PacketType.PORT_OVERREAD,
+    [
+        _VDef("port", _VType.UINT_8, 1),
+        _VDef("high", _VType.BOOL, False)
+    ]
+)

tasd/packets/genesis.py

@@ -0,0 +1,18 @@
+from tasd.packet import _TASDPacketFactory as _TASD_PF, _VariableType as _VType, _VariableDefinition as _VDef, _EnumDefinition as _EDef
+from tasd.constants import PacketType
+
+'''
+ 4.3.4.1. GENESIS_GAME_GENIE_CODE Packet
+'''
+
+GenesisGameGenieCode = _TASD_PF(
+    "GenesisGameGenieCode",
+    PacketType.GENESIS_GAME_GENIE_CODE,
+    [
+        _VDef("code", _VType.STRING_EOP, "")
+    ]
+)
+
+__all__ = [
+    GenesisGameGenieCode
+]

tasd/packets/input.py

@@ -0,0 +1,106 @@
+from tasd.packet import _TASDPacketFactory as _TASD_PF, _VariableType as _VType, _VariableDefinition as _VDef, _EnumDefinition as _EDef
+from tasd.constants import PacketType
+
+'''
+ 4.3.5.1. INPUT_CHUNK Packet 
+'''
+
+InputChunk = _TASD_PF(
+    "InputChunk",
+    PacketType.INPUT_CHUNK,
+    [
+        _VDef("port", _VType.UINT_8, 1),
+        _VDef("data", _VType.BYTES_EOP, b"")
+    ]
+)
+
+'''
+ 4.3.5.2. INPUT_MOMENT Packet
+'''
+
+class INPUT_MOMENT_INDEX_TYPE():
+    FRAME              = 0x01
+    CYCLE_COUNT        = 0x02
+    MILLISECONDS       = 0x03
+    MICROSECONDS_X10   = 0x04
+InputMoment = _TASD_PF(
+    "InputMoment",
+    PacketType.INPUT_MOMENT,
+    [
+        _VDef("port", _VType.UINT_8, 1),
+        _VDef("hold", _VType.BOOL, False),
+        _VDef("index_type", _VType.UINT_8, INPUT_MOMENT_INDEX_TYPE.FRAME),
+        _VDef("index", _VType.UINT_64, 0),
+        _VDef("inputs", _VType.BYTES_EOP, b"")
+    ],
+    [
+        _EDef("INPUT_MOMENT_INDEX_TYPE", INPUT_MOMENT_INDEX_TYPE)
+    ]
+)
+
+'''
+ 4.3.5.3. TRANSITION Packet
+'''
+
+class TRANSITION_INDEX_TYPE():
+    FRAME               = 0x01
+    CYCLE_COUNT         = 0x02
+    MILLISECONDS        = 0x03
+    MICROSECONDS        = 0x04
+    NANOSECONDS         = 0x05
+    INPUT_CHUNK_INDEX   = 0x06
+class TRANSITION_TYPE():
+    SOFT_RESET          = 0x01
+    POWER_RESET         = 0x02
+    RESTART_TASD_FILE   = 0x03
+    PACKET_DERIVED      = 0xFF
+Transition = _TASD_PF(
+    "Transition",
+    PacketType.TRANSITION,
+    [
+        _VDef("port", _VType.UINT_8, 1),
+        _VDef("index_type", _VType.UINT_8, TRANSITION_INDEX_TYPE.FRAME),
+        _VDef("index", _VType.UINT_64, 0),
+        _VDef("type", _VType.UINT_8, TRANSITION_TYPE.SOFT_RESET),
+        _VDef("packet", _VType.BYTES_EOP, b"")
+    ],
+    [
+        _EDef("TRANSITION_INDEX_TYPE", TRANSITION_INDEX_TYPE),
+        _EDef("TRANSITION_TYPE", TRANSITION_TYPE)
+    ]
+)
+
+'''
+ 4.3.5.4. LAG_FRAME_CHUNK Packet
+'''
+
+LagFrameChunk = _TASD_PF(
+    "LagFrameChunk",
+    PacketType.LAG_FRAME_CHUNK,
+    [
+        _VDef("frame", _VType.UINT_32, 0),
+        _VDef("count", _VType.UINT_32, 0)
+    ]
+)
+
+'''
+ 4.3.5.5. MOVIE_TRANSITION
+'''
+
+class MOVIE_TRANSITION_TYPE():
+    SOFT_RESET          = 0x01
+    POWER_RESET         = 0x02
+    RESTART_TASD_FILE   = 0x03
+    PACKET_DERIVED      = 0xFF
+MovieTransition = _TASD_PF(
+    "MovieTransition",
+    PacketType.MOVIE_TRANSITION,
+    [
+        _VDef("frame", _VType.UINT_32, 0),
+        _VDef("type", _VType.UINT_8, MOVIE_TRANSITION_TYPE.SOFT_RESET),
+        _VDef("packet", _VType.BYTES_EOP, b"")
+    ],
+    [
+        _EDef("MOVIE_TRANSITION_TYPE", MOVIE_TRANSITION_TYPE),
+    ]
+)

tasd/packets/nes.py

@@ -0,0 +1,38 @@
+from tasd.packet import _TASDPacketFactory as _TASD_PF, _VariableType as _VType, _VariableDefinition as _VDef, _EnumDefinition as _EDef
+from tasd.constants import PacketType
+
+'''
+ 4.3.2.1. NES_LATCH_FILTER Packet
+'''
+
+NESLatchFilter = _TASD_PF(
+    "NESLatchFilter",
+    PacketType.NES_LATCH_FILTER,
+    [
+        _VDef("time", _VType.UINT_16, 0)
+    ]
+)
+
+'''
+ 4.3.2.2. NES_CLOCK_FILTER Packet
+'''
+
+NESClockFilter = _TASD_PF(
+    "NESClockFilter",
+    PacketType.NES_CLOCK_FILTER,
+    [
+        _VDef("time", _VType.UINT_8, 0)
+    ]
+)
+
+'''
+ 4.3.2.3. NES_GAME_GENIE_CODE Packet
+'''
+
+NESGameGenieCode = _TASD_PF(
+    "NESGameGenieCode",
+    PacketType.NES_GAME_GENIE_CODE,
+    [
+        _VDef("code", _VType.STRING_EOP, "")
+    ]
+)

tasd/packets/snes.py

@@ -0,0 +1,50 @@
+from tasd.packet import _TASDPacketFactory as _TASD_PF, _VariableType as _VType, _VariableDefinition as _VDef, _EnumDefinition as _EDef
+from tasd.constants import PacketType
+
+'''
+ 4.3.3.1. SNES_LATCH_FILTER Packet
+'''
+
+SNESLatchFilter = _TASD_PF(
+    "SNESLatchFilter",
+    PacketType.SNES_LATCH_FILTER,
+    [
+        _VDef("time", _VType.UINT_16, 0)
+    ]
+)
+
+'''
+ 4.3.3.2. SNES_CLOCK_FILTER Packet
+'''
+
+SNESClockFilter = _TASD_PF(
+    "SNESClockFilter",
+    PacketType.SNES_CLOCK_FILTER,
+    [
+        _VDef("time", _VType.UINT_8, 0)
+    ]
+)
+
+'''
+ 4.3.3.3. SNES_GAME_GENIE_CODE Packet
+'''
+
+SNESGameGenieCode = _TASD_PF(
+    "SNESGameGenieCode",
+    PacketType.SNES_GAME_GENIE_CODE,
+    [
+        _VDef("code", _VType.STRING_EOP, "")
+    ]
+)
+
+'''
+ 4.3.3.4. SNES_LATCH_TRAIN Packet
+'''
+
+SNESLatchTrain = _TASD_PF(
+    "SNESLatchTrain",
+    PacketType.SNES_LATCH_TRAIN,
+    [
+        _VDef("trains", _VType.LIST_UINT_64, None)
+    ]
+)

tasd/utils.py

@@ -0,0 +1,128 @@
+def readString(buffer: bytearray, index: int, length: int) -> str:
+    return buffer[index:index+length].decode("utf8")
+def writeString(string: str, buffer: bytearray, index: int) -> None:
+    rawstring = string.encode("utf8")
+    buffer[index:index+len(rawstring)] = rawstring
+def sizeString(string: str) -> int:
+    return len(string.encode("utf8"))
+
+def readBytes(buffer: bytearray, index: int, length: int) -> bytes:
+    return buffer[index:index+length]
+def writeBytes(value: bytes, buffer: bytearray, index: int) -> None:
+    buffer[index:index+len(value)] = value
+
+def readUint8(buffer: bytearray, index: int) -> int:
+    return int.from_bytes(buffer[index:index+1], byteorder="big", signed=False)
+def readUint16(buffer: bytearray, index: int) -> int:
+    return int.from_bytes(buffer[index:index+2], byteorder="big", signed=False)
+def readUint24(buffer: bytearray, index: int) -> int:
+    return int.from_bytes(buffer[index:index+3], byteorder="big", signed=False)
+def readUint32(buffer: bytearray, index: int) -> int:
+    return int.from_bytes(buffer[index:index+4], byteorder="big", signed=False)
+def readUint64(buffer: bytearray, index: int) -> int:
+    return int.from_bytes(buffer[index:index+8], byteorder="big", signed=False)
+def readUintN(buffer: bytearray, index: int, size: int) -> int:
+    if size == 1:
+        return readUint8(buffer, index)
+    if size == 2:
+        return readUint16(buffer, index)
+    if size == 3:
+        return readUint24(buffer, index)
+    if size == 4:
+        return readUint32(buffer, index)
+    raise ValueError("Unsuported UintN size", size)
+
+def writeUint8(value: int, buffer: bytearray, index: int) -> None:
+    buffer[index:index+1] = (value & (2 ** 8 - 1)).to_bytes(1, byteorder="big", signed=False)
+def writeUint16(value: int, buffer: bytearray, index: int) -> None:
+    buffer[index:index+2] = (value & (2 ** 16 - 1)).to_bytes(2, byteorder="big", signed=False)
+def writeUint24(value: int, buffer: bytearray, index: int) -> None:
+    buffer[index:index+3] = (value & (2 ** 24 - 1)).to_bytes(3, byteorder="big", signed=False)
+def writeUint32(value: int, buffer: bytearray, index: int) -> None:
+    buffer[index:index+4] = (value & (2 ** 32 - 1)).to_bytes(4, byteorder="big", signed=False)
+def writeUint64(value: int, buffer: bytearray, index: int) -> None:
+    buffer[index:index+8] = (value & (2 ** 64 - 1)).to_bytes(8, byteorder="big", signed=False)
+def writeUintN(value: int, buffer: bytearray, index: int, size: int) -> None:
+    if size == 1:
+        return writeUint8(value, buffer, index)
+    if size == 2:
+        return writeUint16(value, buffer, index)
+    if size == 3:
+        return writeUint24(value, buffer, index)
+    if size == 4:
+        return writeUint32(value, buffer, index)
+    raise ValueError("Unsuported UintN size", size)
+
+def minUint(value: int) -> int:
+    if value < 256:
+        return 1
+    if value < 65536:
+        return 2
+    if value < 16777216:
+        return 3
+    if value < 4294967296:
+        return 4
+    raise ValueError("Unsupported UInt size", value);
+
+
+def readInt8(buffer: bytearray, index: int) -> int:
+    return int.from_bytes(buffer[index:index+1], byteorder="big", signed=True)
+def readInt16(buffer: bytearray, index: int) -> int:
+    return int.from_bytes(buffer[index:index+2], byteorder="big", signed=True)
+def readInt24(buffer: bytearray, index: int) -> int:
+    return int.from_bytes(buffer[index:index+3], byteorder="big", signed=True)
+def readInt32(buffer: bytearray, index: int) -> int:
+    return int.from_bytes(buffer[index:index+4], byteorder="big", signed=True)
+def readInt64(buffer: bytearray, index: int) -> int:
+    return int.from_bytes(buffer[index:index+8], byteorder="big", signed=True)
+def readIntN(buffer: bytearray, index: int, n: int) -> int:
+    if n == 1:
+        return readInt8(buffer, index)
+    if n == 2:
+        return readInt16(buffer, index)
+    if n == 3:
+        return readInt24(buffer, index)
+    if n == 4:
+        return readInt32(buffer, index)
+    raise ValueError("Unsuported IntN size", n)
+
+def writeInt8(value: int, buffer: bytearray, index: int) -> None:
+    buffer[index:index+1] = (value & (2 ** 8 - 1)).to_bytes(1, byteorder="big", signed=True)
+def writeInt16(value: int, buffer: bytearray, index: int) -> None:
+    buffer[index:index+2] = (value & (2 ** 16 - 1)).to_bytes(2, byteorder="big", signed=True)
+def writeInt24(value: int, buffer: bytearray, index: int) -> None:
+    buffer[index:index+3] = (value & (2 ** 24 - 1)).to_bytes(3, byteorder="big", signed=True)
+def writeInt32(value: int, buffer: bytearray, index: int) -> None:
+    buffer[index:index+4] = (value & (2 ** 32 - 1)).to_bytes(4, byteorder="big", signed=True)
+def writeInt64(value: int, buffer: bytearray, index: int) -> None:
+    buffer[index:index+8] = (value & (2 ** 64 - 1)).to_bytes(8, byteorder="big", signed=True)
+def writeIntN(value: int, buffer: bytearray, index: int, size: int) -> None:
+    if size == 1:
+        return writeInt8(value, buffer, index)
+    if size == 2:
+        return writeInt16(value, buffer, index)
+    if size == 3:
+        return writeInt24(value, buffer, index)
+    if size == 4:
+        return writeInt32(value, buffer, index)
+    raise ValueError("Unsuported IntN size", size)
+
+def minInt(value: int) -> int:
+    if -0x80 <= value <= 0x7f:
+        return 1
+    if -0x8000 <= value <= 0x7fff:
+        return 2
+    if -0x800000 <= value <= 0x7fffff:
+        return 3
+    if -0x80000000 <= value <= 0x7fffffff:
+        return 4
+    raise ValueError("Unsupported Int size", value);
+
+def readBoolean(buffer: bytearray, index: int) -> bool:
+    if buffer[index] == 1:
+        return True
+    if buffer[index] == 0:
+        return False
+    raise ValueError("Invalid Boolean value")
+def writeBoolean(bool: bool, buffer: bytearray, index: int) -> None:
+    buffer[index] = (1 if bool else 0)

tasd-1.0.0.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: tasd
+Version: 1.0.0
+Summary: TASD file serializer and deserializer
+Author-email: TheMas3212 <mas3212@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/themas3212/tasd-py
+Project-URL: Issues, https://github.com/themas3212/tasd-py/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+
+# TASD
+
+This is a python library for the serialization and deserialization of tasd files using the [tasd file specfication](https://tasd.io/)
+
+
+## Installation
+
+Install tasd with pip
+
+```bash
+  pip install tasd
+```
+    
+## Usage/Examples
+
+
+Read a file in a print all the packets in it
+```py
+from tasd import TASD
+
+with open("example.tasd", "rb") as f:
+    file = TASD.from_bytes(f.read())
+
+print(file)
+for packet in file. packets:
+    print(packet)
+```
+
+Create a tasd file from scratch and add packets to it
+```py
+from tasd import TASD, packets
+
+file = TASD()
+file.packets.append(packets.extra.Comment(comment="This is a comment"))
+file.packets.append(packets.general.Attribution(type=packets.general.Attribution.ATTRIBUTION_TYPE.TASD_FILE_CREATOR, name="Me"))
+
+for packet in file. packets:
+    print(packet)
+
+print(file.to_bytes())
+```
+## Brief API Reference
+
+Not an exhaustive list
+
+`tasd.TASD`
+
+Class holding properties of the tasd file itself: Version and KeyLength
+
+`tasd.constants.PACKET_TYPES`
+
+Enumlike class containing the different packet type indentifiers
+
+`tasd.packets`
+
+Submodule containing all the different packet classes
+
+For details about the different packet types i suggest reading the specification document to determine what packets you need to consider for your use case
+## Appendix
+
+Any additional information goes here
+

tasd-1.0.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+tasd/__init__.py,sha256=1yGBy9LKlZOfg7qB2BXhSRECm4ag1eOELMnMKUT5Yns,86
+tasd/constants.py,sha256=A60Y_e_PqF6oCX2VlINZqbRm0ooqGF4azpMuohaHbW0,2149
+tasd/file.py,sha256=CiRx1Vi-vqIzofRcGrWXXIKhz80AqBRgXlsepSw_vcw,2315
+tasd/packet.py,sha256=SFdHIHCb4gKL4eOzNBZwsfJi5O-QLPbgYCDCW3E0iPQ,12204
+tasd/utils.py,sha256=m3dFok1VswQ1Ba5t_nYPLG90Y90KegkLFIvNN4LMJyk,5842
+tasd/packets/__init__.py,sha256=aznvDufzsVEIfHAV__FA3W1bnE4wrQWzsMc5wbMQbqs,157
+tasd/packets/extra.py,sha256=upxQ7_V69nAbNhdCMuO1QFR_QR8ZRywj8YEglkwu0p4,676
+tasd/packets/general.py,sha256=Ib2UZbYAa7aP27X_iyAmBTMJwf7MzUdWYWs0GCE327k,8858
+tasd/packets/genesis.py,sha256=CHqKBRmZjma6Q-VD8S635jBbRZwk2vsNCLV8NVjurRo,424
+tasd/packets/input.py,sha256=OkPQvSC3hbNSVHYYMt1Ss5FI3SLz67j1Z1hHhI5IdsE,2620
+tasd/packets/nes.py,sha256=X4JuKT9TkDvd6PL3PDHCujPKh7V_JAb51NkMVQCg2_s,729
+tasd/packets/snes.py,sha256=GpJmbp-wlSEWC5E__9a0r_9lJ6hrJctzPysZlPNkbNQ,932
+tasd-1.0.0.dist-info/licenses/LICENSE,sha256=g3ow4YGepg8H1fLp2CiNhGHkMFiBvfX1P-JH3oKmA3g,1067
+tasd-1.0.0.dist-info/METADATA,sha256=PEaPbWhxNgP0XlMRhqornw7fjp2-v2iwuwPwUpyoTJI,1841
+tasd-1.0.0.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+tasd-1.0.0.dist-info/top_level.txt,sha256=Ys1rtVCDs2s_wERGa-Z-umkR87S0XWHo9UzpemZxDsg,5
+tasd-1.0.0.dist-info/RECORD,,

tasd-1.0.0.dist-info/WHEEL

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

tasd-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 TheMas3212
+
+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.

tasd-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+tasd