code stringlengths 114 1.05M | path stringlengths 3 312 | quality_prob float64 0.5 0.99 | learning_prob float64 0.2 1 | filename stringlengths 3 168 | kind stringclasses 1
value |
|---|---|---|---|---|---|
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class AudioBusDriver(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[AudioBusDriver]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return AudioBusDriver(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/AudioBusDriver.py | 0.600774 | 0.255019 | AudioBusDriver.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ThardusMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ThardusMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ThardusMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ThardusMP1.py | 0.602296 | 0.258168 | ThardusMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ControllerAction(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ControllerAction]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ControllerAction(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ControllerAction.py | 0.61115 | 0.259878 | ControllerAction.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class LevelDarkener(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[LevelDarkener]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return LevelDarkener(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/LevelDarkener.py | 0.61231 | 0.255367 | LevelDarkener.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class MIDITransmitter(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[MIDITransmitter]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return MIDITransmitter(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/MIDITransmitter.py | 0.609408 | 0.255054 | MIDITransmitter.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class BlackboardBooleanWriter(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[BlackboardBooleanWriter]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return BlackboardBooleanWriter(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/BlackboardBooleanWriter.py | 0.617051 | 0.250821 | BlackboardBooleanWriter.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class LightStatic(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[LightStatic]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return LightStatic(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/LightStatic.py | 0.614047 | 0.25945 | LightStatic.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class CameraPitchVolumeMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CameraPitchVolumeMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return CameraPitchVolumeMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/CameraPitchVolumeMP1.py | 0.645008 | 0.271077 | CameraPitchVolumeMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ActorCollision(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ActorCollision]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ActorCollision(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ActorCollision.py | 0.615781 | 0.253826 | ActorCollision.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class DSP(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[DSP]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return DSP(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/DSP.py | 0.608245 | 0.263013 | DSP.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class DynamicActorControl(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[DynamicActorControl]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return DynamicActorControl(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/DynamicActorControl.py | 0.631253 | 0.252534 | DynamicActorControl.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class AnalogDriver(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[AnalogDriver]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return AnalogDriver(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/AnalogDriver.py | 0.610802 | 0.255158 | AnalogDriver.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class OculusMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[OculusMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return OculusMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/OculusMP1.py | 0.606498 | 0.270694 | OculusMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class PhazonPoolMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PhazonPoolMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return PhazonPoolMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/PhazonPoolMP1.py | 0.60871 | 0.256145 | PhazonPoolMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class NavigationPathPoint(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[NavigationPathPoint]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return NavigationPathPoint(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/NavigationPathPoint.py | 0.612194 | 0.271041 | NavigationPathPoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class AudioObstruction(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[AudioObstruction]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return AudioObstruction(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/AudioObstruction.py | 0.604049 | 0.261001 | AudioObstruction.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class CreatureEvadeBehavior(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CreatureEvadeBehavior]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return CreatureEvadeBehavior(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/CreatureEvadeBehavior.py | 0.60743 | 0.257048 | CreatureEvadeBehavior.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class SimpleSound(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SimpleSound]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return SimpleSound(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/SimpleSound.py | 0.610221 | 0.265309 | SimpleSound.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class TargetableProjectileMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[TargetableProjectileMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return TargetableProjectileMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/TargetableProjectileMP1.py | 0.605216 | 0.261655 | TargetableProjectileMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class SustainedPlayerDamageMP1Runtime(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SustainedPlayerDamageMP1Runtime]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return SustainedPlayerDamageMP1Runtime(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/SustainedPlayerDamageMP1Runtime.py | 0.615319 | 0.25326 | SustainedPlayerDamageMP1Runtime.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class PoisonProjectileMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PoisonProjectileMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return PoisonProjectileMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/PoisonProjectileMP1.py | 0.602296 | 0.260619 | PoisonProjectileMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class CameraOverrideMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CameraOverrideMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return CameraOverrideMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/CameraOverrideMP1.py | 0.645679 | 0.265113 | CameraOverrideMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class RelayMemory(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[RelayMemory]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return RelayMemory(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/RelayMemory.py | 0.60743 | 0.257899 | RelayMemory.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class PlayerInventoryEffects(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerInventoryEffects]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return PlayerInventoryEffects(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/PlayerInventoryEffects.py | 0.627038 | 0.265018 | PlayerInventoryEffects.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class RenderClipPlane(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[RenderClipPlane]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return RenderClipPlane(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/RenderClipPlane.py | 0.612078 | 0.268815 | RenderClipPlane.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ControllerAnalogMovement(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ControllerAnalogMovement]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ControllerAnalogMovement(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ControllerAnalogMovement.py | 0.602062 | 0.258215 | ControllerAnalogMovement.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class FlaahgraMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[FlaahgraMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return FlaahgraMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/FlaahgraMP1.py | 0.596551 | 0.265749 | FlaahgraMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class MidiMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[MidiMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return MidiMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/MidiMP1.py | 0.594904 | 0.26481 | MidiMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class Dock(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[Dock]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return Dock(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/Dock.py | 0.607081 | 0.264323 | Dock.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class RealNumberPhaseResponder(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[RealNumberPhaseResponder]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return RealNumberPhaseResponder(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/RealNumberPhaseResponder.py | 0.609059 | 0.258952 | RealNumberPhaseResponder.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class CombatStateProxy(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CombatStateProxy]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return CombatStateProxy(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/CombatStateProxy.py | 0.599837 | 0.254532 | CombatStateProxy.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class FSMMessage(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[FSMMessage]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return FSMMessage(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/FSMMessage.py | 0.604866 | 0.259967 | FSMMessage.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class IntToRealMap(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[IntToRealMap]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return IntToRealMap(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/IntToRealMap.py | 0.605566 | 0.267199 | IntToRealMap.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class TargetingPointMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[TargetingPointMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return TargetingPointMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/TargetingPointMP1.py | 0.608594 | 0.267976 | TargetingPointMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class Footprint(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[Footprint]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return Footprint(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/Footprint.py | 0.581897 | 0.255303 | Footprint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class InputMacroRecorder(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[InputMacroRecorder]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return InputMacroRecorder(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/InputMacroRecorder.py | 0.602763 | 0.262984 | InputMacroRecorder.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ScriptHUDBillboardEffectMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ScriptHUDBillboardEffectMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ScriptHUDBillboardEffectMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ScriptHUDBillboardEffectMP1.py | 0.616128 | 0.256477 | ScriptHUDBillboardEffectMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class HardwareProxy(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[HardwareProxy]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return HardwareProxy(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/HardwareProxy.py | 0.614625 | 0.251234 | HardwareProxy.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class MetroidPrimeMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[MetroidPrimeMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return MetroidPrimeMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/MetroidPrimeMP1.py | 0.603698 | 0.26569 | MetroidPrimeMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ControlCommandMappingAdd(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ControlCommandMappingAdd]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ControlCommandMappingAdd(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ControlCommandMappingAdd.py | 0.603932 | 0.256442 | ControlCommandMappingAdd.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class PhazonDriverMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PhazonDriverMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return PhazonDriverMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/PhazonDriverMP1.py | 0.605449 | 0.252661 | PhazonDriverMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class OrbitTarget(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[OrbitTarget]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return OrbitTarget(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/OrbitTarget.py | 0.609757 | 0.258022 | OrbitTarget.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ObjectFollow(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ObjectFollow]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ObjectFollow(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ObjectFollow.py | 0.607896 | 0.260008 | ObjectFollow.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class HeightfieldSurfaceDescription(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[HeightfieldSurfaceDescription]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return HeightfieldSurfaceDescription(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/HeightfieldSurfaceDescription.py | 0.629091 | 0.266966 | HeightfieldSurfaceDescription.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class RumbleEffectsDefinition(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[RumbleEffectsDefinition]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return RumbleEffectsDefinition(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/RumbleEffectsDefinition.py | 0.615897 | 0.257473 | RumbleEffectsDefinition.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class GameOptionsAccessor(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[GameOptionsAccessor]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return GameOptionsAccessor(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/GameOptionsAccessor.py | 0.613121 | 0.260337 | GameOptionsAccessor.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ControlSchemesDefinition(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ControlSchemesDefinition]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ControlSchemesDefinition(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ControlSchemesDefinition.py | 0.607547 | 0.255309 | ControlSchemesDefinition.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class CameraSystemHint(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CameraSystemHint]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return CameraSystemHint(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/CameraSystemHint.py | 0.643777 | 0.258034 | CameraSystemHint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class PlayerTeleport(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerTeleport]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return PlayerTeleport(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/PlayerTeleport.py | 0.617743 | 0.253884 | PlayerTeleport.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class BlackboardBoolean(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[BlackboardBoolean]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return BlackboardBoolean(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/BlackboardBoolean.py | 0.61832 | 0.254347 | BlackboardBoolean.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ParasiteMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ParasiteMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ParasiteMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ParasiteMP1.py | 0.602062 | 0.262712 | ParasiteMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class DebugActorMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[DebugActorMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return DebugActorMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/DebugActorMP1.py | 0.601008 | 0.252234 | DebugActorMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class MusicSystemTransport(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[MusicSystemTransport]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return MusicSystemTransport(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/MusicSystemTransport.py | 0.603815 | 0.250374 | MusicSystemTransport.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ActorKeyframePhaseResponder(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ActorKeyframePhaseResponder]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ActorKeyframePhaseResponder(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ActorKeyframePhaseResponder.py | 0.613005 | 0.248774 | ActorKeyframePhaseResponder.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class OriginatorProxy(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[OriginatorProxy]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return OriginatorProxy(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/OriginatorProxy.py | 0.60743 | 0.257112 | OriginatorProxy.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class VolumetricFog(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[VolumetricFog]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return VolumetricFog(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/VolumetricFog.py | 0.619011 | 0.265726 | VolumetricFog.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class PhaseCombinator(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PhaseCombinator]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return PhaseCombinator(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/PhaseCombinator.py | 0.62601 | 0.255605 | PhaseCombinator.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class EnvironmentVarSender(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[EnvironmentVarSender]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return EnvironmentVarSender(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/EnvironmentVarSender.py | 0.60964 | 0.255489 | EnvironmentVarSender.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class AnchorPoint(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[AnchorPoint]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return AnchorPoint(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/AnchorPoint.py | 0.61855 | 0.26827 | AnchorPoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class CreaturePositionLogic_WaypointScripting(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CreaturePositionLogic_WaypointScripting]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return CreaturePositionLogic_WaypointScripting(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/CreaturePositionLogic_WaypointScripting.py | 0.616936 | 0.26941 | CreaturePositionLogic_WaypointScripting.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class PlayerMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return PlayerMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/PlayerMP1.py | 0.614278 | 0.260366 | PlayerMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class PointOfInterestMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PointOfInterestMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return PointOfInterestMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/PointOfInterestMP1.py | 0.615435 | 0.267187 | PointOfInterestMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class CreatureTurnBehavior(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CreatureTurnBehavior]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return CreatureTurnBehavior(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/CreatureTurnBehavior.py | 0.609757 | 0.256698 | CreatureTurnBehavior.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class RidleyMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[RidleyMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return RidleyMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/RidleyMP1.py | 0.603581 | 0.270766 | RidleyMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class BurrowerMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[BurrowerMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return BurrowerMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/BurrowerMP1.py | 0.600774 | 0.258279 | BurrowerMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class Timer(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[Timer]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return Timer(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/Timer.py | 0.615666 | 0.258244 | Timer.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class IntroBossMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[IntroBossMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return IntroBossMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/IntroBossMP1.py | 0.602529 | 0.262836 | IntroBossMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class AutoExposureHint(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[AutoExposureHint]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return AutoExposureHint(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/AutoExposureHint.py | 0.629888 | 0.249584 | AutoExposureHint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class UVTransform(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UVTransform]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return UVTransform(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/UVTransform.py | 0.622115 | 0.270718 | UVTransform.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ElectricBeamProjectileMP1Runtime(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ElectricBeamProjectileMP1Runtime]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ElectricBeamProjectileMP1Runtime(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ElectricBeamProjectileMP1Runtime.py | 0.619471 | 0.273229 | ElectricBeamProjectileMP1Runtime.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class VisorGooMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[VisorGooMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return VisorGooMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/VisorGooMP1.py | 0.611614 | 0.267301 | VisorGooMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class BlackboardRealNumber(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[BlackboardRealNumber]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return BlackboardRealNumber(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/BlackboardRealNumber.py | 0.606615 | 0.257929 | BlackboardRealNumber.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class NavigationMeshDock(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[NavigationMeshDock]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return NavigationMeshDock(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/NavigationMeshDock.py | 0.607081 | 0.27036 | NavigationMeshDock.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ControlCommandMappingNode(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ControlCommandMappingNode]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ControlCommandMappingNode(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ControlCommandMappingNode.py | 0.605449 | 0.262534 | ControlCommandMappingNode.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class FlaahgraTentacleMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[FlaahgraTentacleMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return FlaahgraTentacleMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/FlaahgraTentacleMP1.py | 0.612194 | 0.267235 | FlaahgraTentacleMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class FSMManager(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[FSMManager]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return FSMManager(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/FSMManager.py | 0.602062 | 0.259251 | FSMManager.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ChromaticAberration(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ChromaticAberration]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ChromaticAberration(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ChromaticAberration.py | 0.614278 | 0.273256 | ChromaticAberration.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class NewFlameThrowerMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[NewFlameThrowerMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return NewFlameThrowerMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/NewFlameThrowerMP1.py | 0.614857 | 0.257211 | NewFlameThrowerMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class HUDSuppressor(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[HUDSuppressor]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return HUDSuppressor(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/HUDSuppressor.py | 0.623148 | 0.264732 | HUDSuppressor.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class CreatureScriptedJumpBehavior(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CreatureScriptedJumpBehavior]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return CreatureScriptedJumpBehavior(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/CreatureScriptedJumpBehavior.py | 0.613815 | 0.263546 | CreatureScriptedJumpBehavior.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class PlayerStateChangeMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerStateChangeMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return PlayerStateChangeMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/PlayerStateChangeMP1.py | 0.608245 | 0.264323 | PlayerStateChangeMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class CreatureRules(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CreatureRules]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return CreatureRules(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/CreatureRules.py | 0.605916 | 0.264673 | CreatureRules.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class VoiceEffect(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[VoiceEffect]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return VoiceEffect(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/VoiceEffect.py | 0.611266 | 0.258344 | VoiceEffect.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class CinematicCameraShot(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CinematicCameraShot]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return CinematicCameraShot(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/CinematicCameraShot.py | 0.649134 | 0.263546 | CinematicCameraShot.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class AnimationUserEventRouter(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[AnimationUserEventRouter]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return AnimationUserEventRouter(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/AnimationUserEventRouter.py | 0.609757 | 0.244048 | AnimationUserEventRouter.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class DroneLaserMP1Runtime(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[DroneLaserMP1Runtime]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return DroneLaserMP1Runtime(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/DroneLaserMP1Runtime.py | 0.609757 | 0.253018 | DroneLaserMP1Runtime.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class AnimationMountRider(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[AnimationMountRider]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return AnimationMountRider(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/AnimationMountRider.py | 0.619011 | 0.26497 | AnimationMountRider.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class AnimationEventListener(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[AnimationEventListener]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return AnimationEventListener(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/AnimationEventListener.py | 0.61451 | 0.256099 | AnimationEventListener.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class AdapterManager(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[AdapterManager]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return AdapterManager(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/AdapterManager.py | 0.601594 | 0.25839 | AdapterManager.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ToneSelectorScriptDriven(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ToneSelectorScriptDriven]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ToneSelectorScriptDriven(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ToneSelectorScriptDriven.py | 0.609175 | 0.25378 | ToneSelectorScriptDriven.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ARepulsorMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ARepulsorMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ARepulsorMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ARepulsorMP1.py | 0.605333 | 0.267516 | ARepulsorMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class CustomInterpolation(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CustomInterpolation]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return CustomInterpolation(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/CustomInterpolation.py | 0.625438 | 0.263309 | CustomInterpolation.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class BabygothMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[BabygothMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return BabygothMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/BabygothMP1.py | 0.60288 | 0.263345 | BabygothMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class DetectionPlane(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[DetectionPlane]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return DetectionPlane(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/DetectionPlane.py | 0.618896 | 0.267976 | DetectionPlane.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class AIGenerator(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[AIGenerator]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return AIGenerator(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/AIGenerator.py | 0.606032 | 0.255698 | AIGenerator.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ToneSelectorSequence(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ToneSelectorSequence]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ToneSelectorSequence(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ToneSelectorSequence.py | 0.607197 | 0.260695 | ToneSelectorSequence.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class RelayProbabilityGameMode(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[RelayProbabilityGameMode]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return RelayProbabilityGameMode(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/RelayProbabilityGameMode.py | 0.615435 | 0.268701 | RelayProbabilityGameMode.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class SetAnimVisibilityState(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SetAnimVisibilityState]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return SetAnimVisibilityState(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/SetAnimVisibilityState.py | 0.612657 | 0.260748 | SetAnimVisibilityState.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class WaterRenderVolume(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[WaterRenderVolume]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return WaterRenderVolume(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/WaterRenderVolume.py | 0.612078 | 0.255228 | WaterRenderVolume.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class CreatureFlinch(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CreatureFlinch]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return CreatureFlinch(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/CreatureFlinch.py | 0.604749 | 0.266626 | CreatureFlinch.py | pypi |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.