peppi-py-vladfi 0.9.0__cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

peppi_py/__init__.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+from dataclasses import dataclass
+from ._peppi import read_peppi as _read_peppi, read_slippi as _read_slippi
+from .game import End, Game, Start
+from .parse import dc_from_json, frames_from_sa, RollbackMode
+
+def read_peppi(path: str, skip_frames: bool=False) -> Game:
+	g = _read_peppi(path, skip_frames)
+	return Game(dc_from_json(Start, g.start), g.end and dc_from_json(End, g.end), g.metadata, frames_from_sa(g.frames))
+
+def read_slippi(path: str, skip_frames: bool=False, rollback_mode: RollbackMode=RollbackMode.ALL) -> Game:
+	g = _read_slippi(path, skip_frames)
+	return Game(
+			dc_from_json(Start, g.start),
+			g.end and dc_from_json(End, g.end),
+			g.metadata,
+			frames_from_sa(g.frames, rollback_mode=rollback_mode)
+	)

peppi_py/frame.py

@@ -0,0 +1,135 @@
+from dataclasses import dataclass
+from enum import IntEnum
+
+from pyarrow.lib import (
+	Int8Array, Int16Array, Int32Array, Int64Array,
+	UInt8Array, UInt16Array, UInt32Array, UInt64Array,
+	FloatArray, DoubleArray,
+	ListArray,
+)
+from .util import _repr
+
+@dataclass(slots=True)
+class End:
+	__repr__ = _repr
+	latest_finalized_frame: Int32Array | None = None
+
+@dataclass(slots=True)
+class Position:
+	__repr__ = _repr
+	x: FloatArray
+	y: FloatArray
+
+@dataclass(slots=True)
+class Start:
+	__repr__ = _repr
+	random_seed: UInt32Array
+	scene_frame_counter: UInt32Array | None = None
+
+@dataclass(slots=True)
+class TriggersPhysical:
+	__repr__ = _repr
+	l: FloatArray
+	r: FloatArray
+
+@dataclass(slots=True)
+class Velocities:
+	__repr__ = _repr
+	self_x_air: FloatArray
+	self_y: FloatArray
+	knockback_x: FloatArray
+	knockback_y: FloatArray
+	self_x_ground: FloatArray
+
+@dataclass(slots=True)
+class Velocity:
+	__repr__ = _repr
+	x: FloatArray
+	y: FloatArray
+
+@dataclass(slots=True)
+class Item:
+	__repr__ = _repr
+	type: UInt16Array
+	state: UInt8Array
+	direction: FloatArray
+	velocity: Velocity
+	position: Position
+	damage: UInt16Array
+	timer: FloatArray
+	id: UInt32Array
+	misc: tuple[UInt8Array, UInt8Array, UInt8Array, UInt8Array] | None = None
+	owner: Int8Array | None = None
+	instance_id: UInt16Array | None = None
+
+@dataclass(slots=True)
+class Post:
+	__repr__ = _repr
+	character: UInt8Array
+	state: UInt16Array
+	position: Position
+	direction: FloatArray
+	percent: FloatArray
+	shield: FloatArray
+	last_attack_landed: UInt8Array
+	combo_count: UInt8Array
+	last_hit_by: UInt8Array
+	stocks: UInt8Array
+	state_age: FloatArray | None = None
+	state_flags: tuple[UInt8Array, UInt8Array, UInt8Array, UInt8Array, UInt8Array] | None = None
+	misc_as: FloatArray | None = None
+	airborne: UInt8Array | None = None
+	ground: UInt16Array | None = None
+	jumps: UInt8Array | None = None
+	l_cancel: UInt8Array | None = None
+	hurtbox_state: UInt8Array | None = None
+	velocities: Velocities | None = None
+	hitlag: FloatArray | None = None
+	animation_index: UInt32Array | None = None
+
+@dataclass(slots=True)
+class Pre:
+	__repr__ = _repr
+	random_seed: UInt32Array
+	state: UInt16Array
+	position: Position
+	direction: FloatArray
+	joystick: Position
+	cstick: Position
+	triggers: FloatArray
+	buttons: UInt32Array
+	buttons_physical: UInt16Array
+	triggers_physical: TriggersPhysical
+	raw_analog_x: Int8Array | None = None
+	percent: FloatArray | None = None
+	raw_analog_y: Int8Array | None = None
+
+@dataclass(slots=True)
+class Data:
+	__repr__ = _repr
+	pre: Pre
+	post: Post
+
+@dataclass(slots=True)
+class PortData:
+	__repr__ = _repr
+	leader: Data
+	follower: Data | None = None
+
+class FodPlatform(IntEnum):
+	RIGHT = 0
+	LEFT = 1
+
+@dataclass(slots=True)
+class FodPlatformMove:
+	__repr__ = _repr
+	platform: ListArray
+	height: ListArray
+
+@dataclass(slots=True)
+class Frame:
+	__repr__ = _repr
+	id: object
+	ports: tuple[PortData]
+	items: Item | None = None
+	fod_platforms: FodPlatformMove | None = None

peppi_py/game.py

@@ -0,0 +1,132 @@
+from dataclasses import dataclass
+from enum import IntEnum
+from .frame import Frame
+from .util import _repr
+
+class Port(IntEnum):
+	P1 = 0
+	P2 = 1
+	P3 = 2
+	P4 = 3
+
+class PlayerType(IntEnum):
+	HUMAN = 0
+	CPU = 1
+	DEMO = 2
+
+class Language(IntEnum):
+	JAPANESE = 0
+	ENGLISH = 1
+
+class DashBack(IntEnum):
+	UCF = 1
+	ARDUINO = 2
+
+class ShieldDrop(IntEnum):
+	UCF = 1
+	ARDUINO = 2
+
+class EndMethod(IntEnum):
+	UNRESOLVED = 0
+	TIME = 1
+	GAME = 2
+	RESOLVED = 3
+	NO_CONTEST = 7
+
+@dataclass(slots=True)
+class Scene:
+	__repr__ = _repr
+	major: int
+	minor: int
+
+@dataclass(slots=True)
+class Match:
+	__repr__ = _repr
+	id: str
+	game: int
+	tiebreaker: int
+
+@dataclass(slots=True)
+class Slippi:
+	__repr__ = _repr
+	version: tuple[int, int, int]
+
+@dataclass(slots=True)
+class Netplay:
+	__repr__ = _repr
+	name: str
+	code: str
+	suid: str | None = None
+
+@dataclass(slots=True)
+class Team:
+	__repr__ = _repr
+	color: int
+	shade: int
+
+@dataclass(slots=True)
+class Ucf:
+	__repr__ = _repr
+	dash_back: DashBack | None
+	shield_drop: ShieldDrop | None
+
+@dataclass(slots=True)
+class Player:
+	__repr__ = _repr
+	port: Port
+	character: int
+	type: PlayerType
+	stocks: int
+	costume: int
+	team: Team | None
+	handicap: int
+	bitfield: int
+	cpu_level: int | None
+	offense_ratio: float
+	defense_ratio: float
+	model_scale: float
+	ucf: Ucf | None = None
+	name_tag: str | None = None
+	netplay: Netplay | None = None
+
+@dataclass(slots=True)
+class Start:
+	__repr__ = _repr
+	slippi: Slippi
+	bitfield: tuple[int, int, int, int]
+	is_raining_bombs: bool
+	is_teams: bool
+	item_spawn_frequency: int
+	self_destruct_score: int
+	stage: int
+	timer: int
+	item_spawn_bitfield: tuple[int, int, int, int, int]
+	damage_ratio: float
+	players: tuple[Player, ...]
+	random_seed: int
+	is_pal: bool | None = None
+	is_frozen_ps: bool | None = None
+	scene: Scene | None = None
+	language: Language | None = None
+	match: Match | None = None
+
+@dataclass(slots=True)
+class PlayerEnd:
+	__repr__ = _repr
+	port: Port
+	placement: int
+
+@dataclass(slots=True)
+class End:
+	__repr__ = _repr
+	method: EndMethod
+	lras_initiator: Port | None = None
+	players: tuple[PlayerEnd, ...] | None = None
+
+@dataclass(slots=True)
+class Game:
+	__repr__ = _repr
+	start: Start
+	end: End
+	metadata: dict
+	frames: Frame | None

peppi_py/parse.py

@@ -0,0 +1,196 @@
+import types, typing
+import pyarrow
+import dataclasses as dc
+import functools
+from inflection import underscore
+from enum import Enum
+from .frame import Data, Frame, PortData, Item
+from .frame import FodPlatform, FodPlatformMove
+
+T = typing.TypeVar('T')
+
+def _repr(x):
+	if isinstance(x, pyarrow.Array):
+		s = ', '.join(repr(v.as_py()) for v in x[:3])
+		if len(x) > 3:
+			s += ', ...'
+		return f'[{s}]'
+	elif isinstance(x, tuple):
+		s = ', '.join(_repr(v) for v in x)
+		return f'({s})'
+	elif dc.is_dataclass(x):
+		s = ', '.join(f'{f.name}={_repr(getattr(x, f.name))}' for f in dc.fields(type(x)))
+		return f'{type(x).__name__}({s})'
+	else:
+		return repr(x)
+
+get_origin = functools.cache(typing.get_origin)
+is_dataclass = functools.cache(dc.is_dataclass)
+dc_fields = functools.cache(dc.fields)
+get_args = functools.cache(typing.get_args)
+
+@functools.cache
+def unwrap_union(cls):
+	if get_origin(cls) is types.UnionType:
+		return get_args(cls)[0]
+	else:
+		return cls
+
+def field_from_sa(cls: type[T], arr: pyarrow.Array | None) -> T | pyarrow.Array | None:
+	if arr is None:
+		return None
+	cls = unwrap_union(cls)
+	if is_dataclass(cls):
+		return dc_from_sa(cls, arr)
+	elif get_origin(cls) is tuple:
+		return tuple_from_sa(cls, arr)
+	else:
+		return arr
+
+def arr_field(arr, dc_field: dc.Field):
+	try:
+		return arr.field(dc_field.name)
+	except KeyError:
+		if dc_field.default is dc.MISSING:
+			raise
+		else:
+			return dc_field.default
+
+def dc_from_sa(cls: type[T], arr: pyarrow.StructArray) -> T:
+	return cls(*(field_from_sa(f.type, arr_field(arr, f)) for f in dc_fields(cls)))
+
+def tuple_from_sa(cls: type[tuple], arr: pyarrow.Array) -> tuple:
+	return cls((field_from_sa(t, arr.field(str(idx))) for (idx, t) in enumerate(get_args(cls))))
+
+@functools.cache
+def unwrap_optional(cls: type) -> type | None:
+	if get_origin(cls) is not types.UnionType:
+		return cls
+
+	args = get_args(cls)
+	assert len(args) == 2
+	assert args[1] is types.NoneType
+	return args[0]
+
+# Generic recursion on dataclasses
+def map_dc(cls: type[T], fn: typing.Callable, *xs: T) -> T:
+	unwrapped_cls = unwrap_optional(cls)
+	if unwrapped_cls is not None:
+		# Optional fields might be missing; if so, don't recurse.
+		for x in xs:
+			if x is None:
+				return None
+		cls = unwrapped_cls
+
+	if is_dataclass(cls):
+		return cls(*(
+				map_dc(f.type, fn, *(getattr(x, f.name) for x in xs))
+				for f in dc_fields(cls)
+		))
+	elif get_origin(cls) is tuple:
+		return cls(
+				map_dc(t, fn, *(x[idx] for x in xs))
+				for (idx, t) in enumerate(get_args(cls))
+		)
+	else:
+		return fn(*xs)
+
+def dc_from_la(cls: type[T], la: pyarrow.ListArray) -> T:
+	"""Converts ListArray of Structs into dataclass of ListArrays."""
+	dc_sa = dc_from_sa(cls, la.values)
+	return map_dc(cls, lambda arr: pyarrow.ListArray.from_arrays(la.offsets, arr), dc_sa)
+
+
+class RollbackMode(Enum):
+	ALL = 'all'  # All frames in the replay.
+	FIRST = 'first'  # Only the first frame, as seen by the player
+	LAST = 'last'  # Only the finalized frames; the "true" frame sequence.
+
+def frames_from_sa(
+		arrow_frames,
+		rollback_mode: RollbackMode = RollbackMode.ALL,
+) -> typing.Optional[Frame]:
+	if arrow_frames is None:
+		return None
+
+	# Handle rollback mode
+	if rollback_mode is RollbackMode.FIRST:
+		index = arrow_frames.field('id').tolist()
+		first_indices = []
+		next_idx = index[0]
+		assert next_idx == -123
+		for i, idx in enumerate(index):
+			if idx == next_idx:
+				first_indices.append(i)
+				next_idx += 1
+		arrow_frames = arrow_frames.take(first_indices)
+	elif rollback_mode is RollbackMode.LAST:
+		index = arrow_frames.field('id').tolist()
+		next_idx = index[-1]
+		last_indices = []
+		for i, idx in reversed(list(enumerate(index))):
+			if idx == next_idx:
+				last_indices.append(i)
+				next_idx -= 1
+		assert next_idx == -124
+		last_indices.reverse()
+		arrow_frames = arrow_frames.take(last_indices)
+
+	ports = []
+	port_arrays = arrow_frames.field('ports')
+	for p in ('P1', 'P2', 'P3', 'P4'):
+		try: port = port_arrays.field(p)
+		except KeyError: continue
+		leader = dc_from_sa(Data, port.field('leader'))
+		try: follower = dc_from_sa(Data, port.field('follower'))
+		except KeyError: follower = None
+		ports.append(PortData(leader, follower))
+
+	# Extract items if available
+	items = None
+	try:
+		items_array = arrow_frames.field('item')
+		items = dc_from_la(Item, items_array)
+	except KeyError:
+		pass
+
+	# Extract FoD platforms if available
+	fod_platforms: FodPlatformMove | None = None
+	try:
+		fod_platform_array = arrow_frames.field('fod_platform')
+		fod_platforms = dc_from_la(FodPlatformMove, fod_platform_array)
+	except KeyError:
+		pass
+
+	return Frame(
+		id=arrow_frames.field('id'),
+		ports=tuple(ports),
+		items=items,
+		fod_platforms=fod_platforms
+	)
+
+def field_from_json(cls, json):
+	if json is None:
+		return None
+	cls = unwrap_union(cls)
+	if dc.is_dataclass(cls):
+		return dc_from_json(cls, json)
+	elif typing.get_origin(cls) is tuple:
+		return tuple_from_json(cls, json)
+	elif issubclass(cls, Enum):
+		return cls[underscore(json).upper()]
+	else:
+		return json
+
+def dc_from_json(cls, json):
+	return cls(*(field_from_json(f.type, json.get(f.name)) for f in dc.fields(cls)))
+
+def tuple_from_json(cls, json):
+	child_cls = typing.get_args(cls)[0]
+
+	if type(json) is dict:
+		items = json.items()
+	else:
+		items = enumerate(json)
+
+	return tuple((field_from_json(child_cls, val) for (idx, val) in items))

peppi_py/util.py

@@ -0,0 +1,17 @@
+import pyarrow
+import dataclasses as dc
+
+def _repr(self):
+	if isinstance(self, pyarrow.Array):
+		s = ', '.join(repr(v.as_py()) for v in self[:3])
+		if len(self) > 3:
+			s += ', ...'
+		return f'[{s}]'
+	elif isinstance(self, tuple):
+		s = ', '.join(_repr(v) for v in self)
+		return f'({s})'
+	elif dc.is_dataclass(self):
+		s = ', '.join(f'{f.name}={_repr(getattr(self, f.name))}' for f in dc.fields(type(self)))
+		return f'{type(self).__name__}({s})'
+	else:
+		return repr(self)

peppi_py_vladfi-0.9.0.dist-info/METADATA

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: peppi-py-vladfi
+Version: 0.9.0
+Requires-Dist: pyarrow~=21.0
+Requires-Dist: inflection~=0.5
+Requires-Python: >=3.10

peppi_py_vladfi-0.9.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+peppi_py/__init__.py,sha256=4to3yVoNHnsV1W6kQzCnXn1njIUJdbLL9oYZstq52G8,748
+peppi_py/_peppi.abi3.so,sha256=x6VMDJA_xWqpD3vtuuDI2Obrz8fWJiOo-L5vEWjp_1o,2440648
+peppi_py/frame.py,sha256=l1f0nyvWPTCo5ZDmFg5gYiNTum8nE8J5fI9xMnRto4k,2942
+peppi_py/game.py,sha256=3oWv15Ik96mJ0glTEa0z2PxRzjvJtcWhWu8hJshjFmk,2222
+peppi_py/parse.py,sha256=veTt3er79VeVmT4qedX_zM_Mq7p_CC1OMGhiG_E1k2w,5332
+peppi_py/util.py,sha256=z6Q_NUCOwlpmpvQggkbQv1RNXX52Q7Nis0apXKb4_XU,475
+peppi_py_vladfi-0.9.0.dist-info/METADATA,sha256=-PtlNUXkZC4uPC1h8bsBAK1BazmD6JwdPbxJE5vYSmQ,143
+peppi_py_vladfi-0.9.0.dist-info/WHEEL,sha256=GOcqNI272zbCryxmLtJmciY1wvncsOuTwTM3MFIoyvQ,145
+peppi_py_vladfi-0.9.0.dist-info/RECORD,,

peppi_py_vladfi-0.9.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp310-abi3-manylinux_2_17_x86_64
+Tag: cp310-abi3-manylinux2014_x86_64