tasd 1.0.0__tar.gz

tasd-1.0.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,63 @@
+
+# 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/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "tasd"
+version = "1.0.0"
+authors = [
+  { name="TheMas3212", email="mas3212@gmail.com" },
+]
+description = "TASD file serializer and deserializer"
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://github.com/themas3212/tasd-py"
+Issues = "https://github.com/themas3212/tasd-py/issues"
+
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"

tasd-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tasd-1.0.0/tasd/__init__.py

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

tasd-1.0.0/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-1.0.0/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-1.0.0/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-1.0.0/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-1.0.0/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"")
+    ]
+)