def _read(self, buffer, *args, **kwargs):
# Should detect little endian byte order accordingly and remove the BOM
data = buffer.read().decode('utf-16')
match = self._regex_parse.match(data)
if not match:
raise ParserError(
'Failed to find the base information. File may not be a .idt file or malformed.'
)
textures = TextureList()
for tex_match in self._regex_texture.finditer(match.group('textures')):
coordinates = CoordinateList()
for coord_match in self._regex_coordinates.finditer(
tex_match.group('coordinates')):
coordinates.append(CoordinateRecord(**coord_match.groupdict()))
if len(coordinates) != int(tex_match.group('count')):
raise ParserError(
'Amount of found coordinates (%s) does not match the amount of specified coordinates (%s)'
% (len(coordinates), tex_match.group('count')))
textures.append(TextureRecord(tex_match.group('name'),
coordinates))
if len(textures) != int(match.group('texture_count')):
raise ParserError(
'Amount of found textures (%s) does not match the amount of specified textures (%s)'
% (len(textures), match.group('texture_count')))
self._records = textures
self.version = int(match.group('version'))
self.image = match.group('image')
def __init__(self, parent, name=None, *args, **kwargs):
super().__init__(*args, **kwargs)
self.parent: 'AbstractKeyValueFile' = parent
if name:
self.name: str = name
elif self.NAME:
self.name: str = self.NAME
else:
raise ParserError('Missing name for section')
def __init__(self, parent, name=None, *args, **kwargs):
super().__init__(*args, **kwargs)
self.parent = parent
if name:
self.name = name
elif self.NAME:
self.name = self.NAME
else:
raise ParserError('Missing name for section')
def extract_dds(self, data: bytes) -> bytes:
"""
Attempts to extract a .dds from the given data bytes.
.dds files in the content.ggpk may be compressed with brotli or may be
a reference to another .dds file.
This function will take of those kind of files accordingly and try to return
a file instead.
If any problems arise an error will be raised instead.
Parameters
----------
data
The raw data to extract the dds from.
Returns
-------
bytes
the uncompressed, dereferenced .dds file data
Raises
-------
ValueError
If the file data contains a reference, but path_or_ggpk is not specified
TypeError
If the file data contains a reference, but path_or_ggpk is of invalid
type (i.e. not str or :class:`GGPKFile`
ParserError
If the uncompressed size does not match the size in the header
brotli.error
If whatever bytes were read were not brotli compressed
"""
# Already a DDS file, so return it
if data[:4] == b'DDS ':
return data
# Is this a reference?
elif data[:1] == b'*':
path = data[1:].decode()
data = self.get_file(path)
return self.extract_dds(data)
else:
size = int.from_bytes(data[:4], 'little')
dec = brotli.decompress(data[4:])
if len(dec) != size:
raise ParserError(
'Decompressed size does not match size in the header')
return dec
def build_directory(self, parent: DirectoryNode = None) -> DirectoryNode:
"""
Rebuilds the directory or the specified :class:`DirectoryNode`
If the root directory is rebuild it will be stored in the directory
object variable.
Parameters
----------
parent : :class:`DirectoryNode` or None
parent :class:`DirectoryNode`. If None generate the root directory
Returns
-------
DirectoryNode
Returns the parent node or the root node if parent was None
Raises
------
ParserError
if performed without calling .read() first
if offsets pointing to records types which are not
:class:`FileRecord` or :class:`DirectoryRecord`
"""
if not self.records:
raise ParserError('No records - perform .read() first')
# Build Root directory
if parent is None:
ggpkrecord = self.records[0]
for offset in ggpkrecord.offsets:
record = self.records[offset]
if isinstance(record, DirectoryRecord):
break
if not isinstance(record, DirectoryRecord):
raise ParserError('GGPKRecord does not contain a DirectoryRecord,\
got %s' % type(record))
root = DirectoryNode(
parent=None,
is_file=False,
record=record,
hash=None,
)
self.directory = root
else:
root = parent
l = []
for entry in root.record.entries:
l.append((entry.offset, entry.hash, root))
try:
while True:
offset, hash, parent = l.pop()
try:
record = self.records[offset]
except KeyError:
pass
else:
node = DirectoryNode(
parent=parent,
is_file=isinstance(record, FileRecord),
record=record,
hash=hash,
)
parent.children[record.name] = node
if node.is_directory:
for entry in record.entries:
l.append((entry.offset, entry.hash, node))
except IndexError:
pass
return root
def _read(self, buffer, *args, **kwargs):
data = buffer.read().decode('utf-16')
match = self._re_header.match(data)
if match is None:
raise ParserError(
'File is not a valid %s file.' % self.__class__.__name__
)
self.version = int(match.group('version'))
for section_match in self._re_find_kv_sections.finditer(
match.group('remainder')):
key = section_match.group('key')
try:
section = self[key]
except KeyError:
#print('Extra section:', key)
section = AbstractKeyValueSection(parent=self, name=key)
self[key] = section
for kv_match in self._re_find_kv_pairs.finditer(
section_match.group('contents')):
value = kv_match.group('value').strip('"')
if value == 'true':
value = True
elif value == 'false':
value = False
else:
try:
value = int(value)
except ValueError:
try:
value = float(value)
except ValueError:
pass
section[kv_match.group('key')] = value
extend = match.group('extends')
if extend == 'nothing':
self.extends = None
elif extend:
if self._parent_file:
self.merge(self._parent_file)
if self._parent_file.name != extend:
warnings.warn(
'Parent file name "%s" doesn\'t match extended file '
'name "%s"' % (self._parent_file.name, extend),
ParserWarning,
)
elif self._parent_file_system:
obj = self.__class__(
parent_or_file_system=self._parent_file_system
)
obj.read(
file_path_or_raw=self._parent_file_system.get_file(
extend + self.EXTENSION
),
)
self.merge(obj)
else:
raise ParserError(
'File extends "%s", but parent_or_file_system has not '
'been specified on class creation.' % extend
)
self.extends = extend
def extract_dds(data, path_or_ggpk=None):
"""
Attempts to extract a .dds from the given data bytes.
.dds files in the content.ggpk may be compressed with brotli or may be
a reference to another .dds file.
This function will take of those kind of files accordingly and try to return
a file instead.
If any problems arise an error will be raised instead.
Parameters
----------
data : bytes
The raw data to extract the dds from.
path_or_ggpk : str or GGPKFile
A str containing the path where the extracted content.ggpk is located or
an :class:`GGPKFile` instance
Returns
-------
bytes
the uncompressed, dereferenced .dds file data
Raises
-------
ValueError
If the file data contains a reference, but path_or_ggpk is not specified
TypeError
If the file data contains a reference, but path_or_ggpk is of invalid
type (i.e. not str or :class:`GGPKFile`
ParserError
If the uncompressed size does not match the size in the header
brotli.error
If whatever bytes were read were not brotli compressed
"""
# Already a DDS file, so return it
if data[:4] == b'DDS ':
return data
# Is this a reference?
elif data[:1] == b'*':
path = data[1:].decode()
if path_or_ggpk is None:
raise ValueError(
'.dds file is a reference, but path_or_ggpk is not specified.')
elif isinstance(path_or_ggpk, GGPKFile):
data = path_or_ggpk.directory[path].record.extract().read()
elif isinstance(path_or_ggpk, str):
with open(os.path.join(path_or_ggpk, path), 'rb') as f:
data = f.read()
else:
raise TypeError('path_or_ggpk has an invalid type "%s" %' %
type(path_or_ggpk))
return extract_dds(
data,
path_or_ggpk=path_or_ggpk,
)
else:
size = int.from_bytes(data[:4], 'little')
dec = brotli.decompress(data[4:])
if len(dec) != size:
raise ParserError(
'Decompressed size does not match size in the header')
return dec