pyddtas 0.1.0__py3-none-any.whl

pyddtas/core.py

@@ -0,0 +1,223 @@
+from ctypes import sizeof
+from typing import Type, Literal
+from dataclasses import dataclass
+import zlib
+
+try: import orjson as json
+except: import json
+
+# Dataclass format:
+#   someParam: type     # exact json key in TAS file
+#
+# if exact key not provided, its literally like class parameter
+
+@dataclass
+class TASInput:
+    direction: int      # m_Direction
+    fire: int           # m_Fire
+    hook: int           # m_Hook
+    jump: int           # m_Jump
+    nextWeapon: int     # m_NextWeapon
+    playerFlags: int    # m_PlayerFlags
+    prevWeapon: int     # m_PrevWeapon
+    targetX: int        # m_TargetX
+    targetY: int        # m_TargetY
+    wantedWeapon: int   # m_WantedWeapon
+
+    def todict(self):
+        return {
+            "m_Direction": self.direction,
+            "m_Fire": self.fire,
+            "m_Hook": self.hook,
+            "m_Jump": self.jump,
+            "m_NextWeapon": self.nextWeapon,
+            "m_PlayerFlags": self.playerFlags,
+            "m_PrevWeapon": self.prevWeapon,
+            "m_TargetX": self.targetX,
+            "m_TargetY": self.targetY,
+            "m_WantedWeapon": self.wantedWeapon
+        }
+
+    def tojson(self, indent: int | str | None = None):
+        return json.dumps(self.todict(), indent=indent)
+
+    @classmethod
+    def fromdict(cls: Type[TASInput], obj: dict, errors: Literal['show', 'ignore'] = "show"):
+        if errors == "ignore": getVal = lambda key, default: obj.get(key, default)
+        else: getVal = lambda key, default: obj[key]
+
+        return cls(
+            direction=getVal("m_Direction", 0),
+            fire=getVal("m_Fire", 0),
+            hook=getVal("m_Hook", 0),
+            jump=getVal("m_Jump", 0),
+            nextWeapon=getVal("m_NextWeapon", 0),
+            playerFlags=getVal("m_PlayerFlags", 0),
+            prevWeapon=getVal("m_PrevWeapon", 0),
+            targetX=getVal("m_TargetX", 0),
+            targetY=getVal("m_TargetY", 0),
+            wantedWeapon=getVal("m_WantedWeapon", 0),
+        )
+    
+    @classmethod
+    def fromjson(cls: Type[TASInput], obj: str | bytes, errors: Literal['show', 'ignore'] = "show"):
+        return cls.fromdict(
+            json.loads(obj),
+            errors
+        )
+
+@dataclass
+class TASPos:
+    x: int
+    y: int
+
+    def todict(self):
+        return {
+            "x": self.x,
+            "y": self.y
+        }
+    
+    def tojson(self, indent: int | str | None = None):
+        return json.dumps(self.todict(), indent=indent)
+    
+    @classmethod
+    def fromdict(cls: Type[TASPos], obj: dict, errors: Literal['show', 'ignore'] = "show"):
+        if errors == "ignore": getVal = lambda key, default: obj.get(key, default)
+        else: getVal = lambda key, default: obj[key]
+
+        return cls(
+            x=getVal("x", 0),
+            y=getVal("y", 0)
+        )
+    
+    @classmethod
+    def fromjson(cls: Type[TASPos], obj: str | bytes, errors: Literal['show', 'ignore'] = "show"):
+        return cls.fromdict(
+            json.loads(obj),
+            errors
+        )
+
+@dataclass
+class TASTick:
+    input: TASInput
+    pos: TASPos
+
+    def todict(self):
+        return {
+            "input": self.input.todict(),
+            "pos": self.pos.todict()
+        }
+    
+    def tojson(self, indent: int | str | None = None):
+        return json.dumps(self.todict(), indent=indent)
+    
+    @classmethod
+    def fromdict(cls: Type[TASTick], obj: dict, errors: Literal['show', 'ignore'] = "show"):
+        if errors == "ignore": getVal = lambda key, default: obj.get(key, default)
+        else: getVal = lambda key, default: obj[key]
+
+        return cls(
+            input=TASInput.fromdict(getVal("input", {})),
+            pos=TASPos.fromdict(getVal("pos", {}))
+        )
+    
+    @classmethod
+    def fromjson(cls: Type[TASTick], obj: str | bytes, errors: Literal['show', 'ignore'] = "show"):
+        return cls.fromdict(
+            json.loads(obj),
+            errors
+        )
+
+@dataclass
+class TASInfo:
+    author: str
+    date_modified: str
+    description: str
+    map: str
+    map_name: str | None = None  # has no key in TAS file, PyTAS value
+    map_hash: str | None = None  # has no key in TAS file, PyTAS value
+
+    def todict(self):
+        return {
+            "author": self.author,
+            "date_modified": self.date_modified,
+            "description": self.description,
+            "map": self.map
+        }
+    
+    def tojson(self, indent: int | str | None = None):
+        return json.dumps(self.todict(), indent=indent)
+    
+    @classmethod
+    def fromdict(cls: Type[TASInfo], obj: dict, errors: Literal['show', 'ignore'] = "show"):
+        if errors == "ignore": getVal = lambda key, default: obj.get(key, default)
+        else: getVal = lambda key, default: obj[key]
+
+        return cls(
+            author=getVal("author", ""),
+            date_modified=getVal("date_modified", ""),
+            description=getVal("description", ""),
+            map=getVal("map", ""),
+            map_name=getVal("map", "").split("_")[0] if len(getVal("map", "").split("_")) == 2 else None,
+            map_hash=getVal("map", "").split("_")[1] if len(getVal("map", "").split("_")) == 2 else None
+        )
+    
+    @classmethod
+    def fromjson(cls: Type[TASInfo], obj: str | bytes, errors: Literal['show', 'ignore'] = "show"):
+        return cls.fromdict(
+            json.loads(obj),
+            errors
+        )
+
+@dataclass
+class TASData:
+    info: TASInfo
+    replay_dummy: list[TASTick]
+    replay_local: list[TASTick]
+
+    def todict(self):
+        return {
+            "info": self.info.todict(),
+            "replay_dummy": [x.todict() for x in self.replay_dummy],
+            "replay_local": [x.todict() for x in self.replay_local]
+        }
+    
+    def tojson(self, indent: int | str | None = None):
+        return json.dumps(self.todict(), indent=indent)
+    
+    @classmethod
+    def fromdict(cls: Type[TASData], obj: dict, errors: Literal['show', 'ignore'] = "show"):
+        if errors == "ignore": getVal = lambda key, default: obj.get(key, default)
+        else: getVal = lambda key, default: obj[key]
+
+        return cls(
+            info=TASInfo.fromdict(getVal("info", {})),
+            replay_dummy=[TASTick.fromdict(x) for x in getVal("replay_dummy", [])],
+            replay_local=[TASTick.fromdict(x) for x in getVal("replay_local", [])]
+        )
+    
+    @classmethod
+    def fromjson(cls: Type[TASData], obj: str | bytes, errors: Literal['show', 'ignore'] = "show"):
+        return cls.fromdict(
+            json.loads(obj),
+            errors
+        )
+
+@dataclass
+class TASFile:
+    tas_data: TASData
+
+    def tobytes(self):
+        data = self.tas_data.tojson().encode("utf-8")
+        uncsize = len(data).to_bytes(4, "little")
+        compressed = zlib.compress(data)
+        return uncsize + compressed
+    
+    @classmethod
+    def frombytes(cls: Type[TASFile], data: bytes, ignore_size: bool = False):
+        uncsize = int.from_bytes(data[:4], "little")
+        data = zlib.decompress(data[4:])
+        if len(data) != uncsize and not ignore_size: raise ValueError("Uncompressed size from header is not equal to real uncompressed size. (damaged file)")
+        return cls(
+            TASData.fromdict(json.loads(data))
+        )

pyddtas-0.1.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: pyddtas
+Version: 0.1.0
+Author-email: nesquikcode <nesquik@nishine.ru>
+Requires-Python: >=3.11
+Provides-Extra: fast
+Requires-Dist: orjson>=3.10; extra == "fast"

pyddtas-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+pyddtas/core.py,sha256=PzwJRycTIBoVai_nSrLA7Z4V5UdEUOUbjYJE-gGyUac,7439
+pyddtas-0.1.0.dist-info/METADATA,sha256=YFznqhxGaz15wOJVfnkDHbMg90pbMtuw7P8n5geaXLA,195
+pyddtas-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pyddtas-0.1.0.dist-info/top_level.txt,sha256=G6PfuX0HldtGmzyi4DN109Ndm44WqUuuuP5Xt2QWHl0,8
+pyddtas-0.1.0.dist-info/RECORD,,

pyddtas-0.1.0.dist-info/WHEEL

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

pyddtas-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyddtas