pyddtas 0.1.0__tar.gz

pyddtas-0.1.0/PKG-INFO

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

@@ -0,0 +1,17 @@
+# About
+PyTAS is a pythonic version of parser/writer of .tas files from KRX DDNet client.
+
+# Usage
+PyTAS including dataclasses for interacting with .tas format, import all of them using `from pyddtas.core import *`.
+
+## PyTAS dataclasses
+ > TASFile: .tas file itself
+ >> TASData: JSON data from file (info, movements)
+ >>> TASInfo: some info about .tas file, like author, description or map info (name, hash)
+ >>> TASTick: every tick state such as inputs or position
+ >>>> TASInput: client\`s inputs
+ >>>> TASPos: client\`s position
+
+# Building
+1. Install requirements using `pip install requirements.txt`
+2. Build project with `python -m build`

pyddtas-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "pyddtas"
+authors = [{name = "nesquikcode", email = "nesquik@nishine.ru"}]
+version = "0.1.0"
+requires-python = ">=3.11"
+dependencies = []
+
+[project.optional-dependencies]
+fast = [
+    "orjson>=3.10"
+]
+
+[build-system]
+requires = ["setuptools>=80", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

pyddtas-0.1.0/setup.cfg

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

pyddtas-0.1.0/src/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/src/pyddtas.egg-info/PKG-INFO

@@ -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/src/pyddtas.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+src/pyddtas/core.py
+src/pyddtas.egg-info/PKG-INFO
+src/pyddtas.egg-info/SOURCES.txt
+src/pyddtas.egg-info/dependency_links.txt
+src/pyddtas.egg-info/requires.txt
+src/pyddtas.egg-info/top_level.txt
+test/test.py

pyddtas-0.1.0/src/pyddtas.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyddtas-0.1.0/src/pyddtas.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[fast]
+orjson>=3.10

pyddtas-0.1.0/src/pyddtas.egg-info/top_level.txt

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

pyddtas-0.1.0/test/test.py

@@ -0,0 +1,4 @@
+from pyddtas.core import *
+
+file = TASFile.frombytes(open("some.tas", "rb").read())
+print(file)