addressablestools 0.1.0__py3-none-any.whl

AddressablesTools/AddressablesCatalogFileParser.py

@@ -0,0 +1,104 @@
+import json
+from io import BytesIO
+
+from .CatalogFileType import CatalogFileType
+from .JSON.ContentCatalogDataJson import ContentCatalogDataJson
+from .JSON.ObjectInitializationDataJson import ObjectInitializationDataJson
+from .JSON.SerializedTypeJson import SerializedTypeJson
+from .Catalog.ContentCatalogData import ContentCatalogData
+from .Reader.CatalogBinaryReader import CatalogBinaryReader
+
+
+def serializedTypeDecoder(obj: dict):
+    return SerializedTypeJson.New(obj["m_AssemblyName"], obj["m_ClassName"])
+
+
+def objectInitializationDataDecoder(obj: dict):
+    _m_ObjectType = obj["m_ObjectType"]
+    m_ObjectType = SerializedTypeJson.New(
+        _m_ObjectType["m_AssemblyName"], _m_ObjectType["m_ClassName"]
+    )
+    return ObjectInitializationDataJson.New(obj["m_Id"], m_ObjectType, obj["m_Data"])
+
+
+def contentCatalogDataDecoder(obj: dict):
+    _m_InstanceProviderData = obj["m_InstanceProviderData"]
+    _m_SceneProviderData = obj["m_SceneProviderData"]
+    _m_ResourceProviderData = obj["m_ResourceProviderData"]
+
+    m_InstanceProviderData = ObjectInitializationDataJson.New(
+        _m_InstanceProviderData["m_Id"],
+        SerializedTypeJson.New(
+            _m_InstanceProviderData["m_ObjectType"]["m_AssemblyName"],
+            _m_InstanceProviderData["m_ObjectType"]["m_ClassName"],
+        ),
+        _m_InstanceProviderData["m_Data"],
+    )
+
+    m_SceneProviderData = ObjectInitializationDataJson.New(
+        _m_SceneProviderData["m_Id"],
+        SerializedTypeJson.New(
+            _m_SceneProviderData["m_ObjectType"]["m_AssemblyName"],
+            _m_SceneProviderData["m_ObjectType"]["m_ClassName"],
+        ),
+        _m_SceneProviderData["m_Data"],
+    )
+
+    m_ResourceProviderData = [
+        ObjectInitializationDataJson.New(
+            o["m_Id"],
+            SerializedTypeJson.New(
+                o["m_ObjectType"]["m_AssemblyName"], o["m_ObjectType"]["m_ClassName"]
+            ),
+            o["m_Data"],
+        )
+        for o in _m_ResourceProviderData
+    ]
+
+    return ContentCatalogDataJson.New(
+        obj["m_LocatorId"],
+        obj.get("m_BuildResultHash"),
+        m_InstanceProviderData,
+        m_SceneProviderData,
+        m_ResourceProviderData,
+        obj["m_ProviderIds"],
+        obj["m_InternalIds"],
+        obj["m_KeyDataString"],
+        obj["m_BucketDataString"],
+        obj["m_EntryDataString"],
+        obj["m_ExtraDataString"],
+        obj.get("m_Keys"),
+        [
+            SerializedTypeJson.New(o["m_AssemblyName"], o["m_ClassName"])
+            for o in obj["m_resourceTypes"]
+        ],
+        obj.get("m_InternalIdPrefixes"),
+    )
+
+
+class AddressablesCatalogFileParser:
+    @staticmethod
+    def CCDJsonFromString(data: str) -> ContentCatalogDataJson:
+        return contentCatalogDataDecoder(json.loads(data))
+
+    @staticmethod
+    def FromBinaryData(data: bytes) -> ContentCatalogData:
+        ms = BytesIO(data)
+        reader = CatalogBinaryReader(ms)
+        catalogData = ContentCatalogData()
+        catalogData.ReadBinary(reader)
+        return catalogData
+
+    @staticmethod
+    def FromJsonString(data: str) -> ContentCatalogData:
+        ccdJson = AddressablesCatalogFileParser.CCDJsonFromString(data)
+        catalogData = ContentCatalogData()
+        catalogData.ReadJson(ccdJson)
+        return catalogData
+
+    @staticmethod
+    def GetCatalogFileType() -> CatalogFileType:
+        return CatalogFileType.Null
+
+
+__all__ = ["AddressablesCatalogFileParser"]

AddressablesTools/Binary/ContentCatalogDataBinaryHeader.py

@@ -0,0 +1,45 @@
+from ..Reader import CatalogBinaryReader
+from ..Const import uint
+
+
+class ContentCatalogDataBinaryHeader:
+    Magic: int
+    Version: int
+    KeysOffset: int
+    IdOffset: int
+    InstanceProviderOffset: int
+    SceneProviderOffset: int
+    InitObjectsArrayOffset: int
+    BuildResultHashOffset: int
+
+    def __repr__(self):
+        return (
+            f"<{self.__class__.__name__}(Magic={self.Magic}, Version={self.Version})>"
+        )
+
+    def __init__(self):
+        self.Magic = 0
+        self.Version = 0
+        self.KeysOffset = 0
+        self.IdOffset = 0
+        self.InstanceProviderOffset = 0
+        self.SceneProviderOffset = 0
+        self.InitObjectsArrayOffset = 0
+        self.BuildResultHashOffset = 0
+
+    def Read(self, reader: CatalogBinaryReader):
+        self.Magic = reader.ReadInt32()
+        self.Version = reader.ReadInt32()
+        if self.Version not in [1, 2]:
+            raise Exception("Only versions 1 and 2 are supported")
+        reader.Version = self.Version
+
+        self.KeysOffset = reader.ReadUInt32()
+        self.IdOffset = reader.ReadUInt32()
+        self.InstanceProviderOffset = reader.ReadUInt32()
+        self.SceneProviderOffset = reader.ReadUInt32()
+        self.InitObjectsArrayOffset = reader.ReadUInt32()
+        if self.Version == 1 and self.KeysOffset == 0x20:
+            self.BuildResultHashOffset = uint.MaxValue
+        else:
+            self.BuildResultHashOffset = reader.ReadUInt32()

AddressablesTools/Catalog/ClassJsonObject.py

@@ -0,0 +1,18 @@
+from .SerializedType import SerializedType
+
+
+class ClassJsonObject:
+    Type: SerializedType
+    JsonText: str | None
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__}(Type={self.Type})>"
+
+    def __init__(self, assemblyName: str, className: str, jsonText: str):
+        self.Type = SerializedType()
+        self.Type.AssemblyName = assemblyName
+        self.Type.ClassName = className
+        self.JsonText = className
+
+
+__all__ = ["ClassJsonObject"]

AddressablesTools/Catalog/ContentCatalogData.py

@@ -0,0 +1,255 @@
+from io import BytesIO
+from base64 import b64decode
+
+from .ObjectInitializationData import ObjectInitializationData
+from .ResourceLocation import ResourceLocation
+from .SerializedObjectDecoder import SerializedObjectDecoder
+from .SerializedType import SerializedType
+from ..Binary.ContentCatalogDataBinaryHeader import ContentCatalogDataBinaryHeader
+from ..JSON.ContentCatalogDataJson import ContentCatalogDataJson
+from ..Reader.CatalogBinaryReader import CatalogBinaryReader
+from ..Reader.BinaryReader import BinaryReader
+from ..Catalog.ClassJsonObject import ClassJsonObject
+from ..Classes.TypeReference import TypeReference
+from ..Classes.Hash128 import Hash128
+from ..Catalog.WrappedSerializedObject import WrappedSerializedObject
+from ..Classes.AssetBundleRequestOptions import AssetBundleRequestOptions
+
+
+class ContentCatalogData:
+    Version: int
+
+    LocatorId: str | None
+    BuildResultHash: str | None
+    InstanceProviderData: ObjectInitializationData | None
+    SceneProviderData: ObjectInitializationData | None
+    ResourceProviderData: list[ObjectInitializationData] | None
+    ProviderIds: list[str] | None
+    InternalIds: list[str] | None
+    Keys: list[str] | None
+    ResourceTypes: list[SerializedType] | None
+    InternalIdPrefixes: list[str] | None
+    Resources: dict[object, list[ResourceLocation]] | None
+
+    Header: ContentCatalogDataBinaryHeader | None
+
+    class Bucket:
+        offset: int
+        entries: list[int]
+
+        def __repr__(self):
+            return f"<{self.__class__.__name__}>"
+
+        def __init__(self, offset: int, entries: list[int]):
+            self.offset = offset
+            self.entries = entries
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__}(LocatorId={self.LocatorId}, BuildResultHash={self.BuildResultHash})>"
+
+    def __init__(self):
+        self.LocatorId = None
+        self.BuildResultHash = None
+        self.InstanceProviderData = None
+        self.SceneProviderData = None
+        self.ResourceProviderData = None
+        self.ProviderIds = None
+        self.InternalIds = None
+        self.Keys = None
+        self.ResourceTypes = None
+        self.InternalIdPrefixes = None
+        self.Resources = None
+
+        self.Header = None
+
+    def ReadJson(self, data: ContentCatalogDataJson):
+        self.LocatorId = data.m_LocatorId
+        self.BuildResultHash = data.m_BuildResultHash
+
+        self.InstanceProviderData = ObjectInitializationData()
+        self.InstanceProviderData.ReadJson(data.m_InstanceProviderData)
+
+        self.SceneProviderData = ObjectInitializationData()
+        self.SceneProviderData.ReadJson(data.m_SceneProviderData)
+
+        self.ResourceProviderData = []
+        for i in range(len(data.m_ResourceProviderData)):
+            o = ObjectInitializationData()
+            o.ReadJson(data.m_ResourceProviderData[i])
+            self.ResourceProviderData.append(o)
+
+        self.ProviderIds = []
+        for i in range(len(data.m_ProviderIds)):
+            self.ProviderIds.append(data.m_ProviderIds[i])
+
+        self.InternalIds = []
+        for i in range(len(data.m_InternalIds)):
+            self.InternalIds.append(data.m_InternalIds[i])
+
+        if data.m_Keys is not None:
+            self.Keys = []
+            for i in range(len(data.m_Keys)):
+                self.Keys.append(data.m_Keys[i])
+        else:
+            self.Keys = None
+
+        self.ResourceTypes = []
+        for i in range(len(data.m_resourceTypes)):
+            o = SerializedType()
+            o.ReadJson(data.m_resourceTypes[i])
+            self.ResourceTypes.append(o)
+
+        if data.m_InternalIdPrefixes is not None:
+            self.InternalIdPrefixes = []
+            for i in range(len(data.m_InternalIdPrefixes)):
+                self.InternalIdPrefixes.append(data.m_InternalIdPrefixes[i])
+        else:
+            self.InternalIdPrefixes = None
+
+        self.ReadResourcesJson(data)
+
+    def ReadBinary(self, reader: CatalogBinaryReader):
+        header = ContentCatalogDataBinaryHeader()
+        header.Read(reader)
+
+        self.Version = reader.Version
+        self.Header = header
+
+        self.LocatorId = reader.ReadEncodedString(header.IdOffset)
+        self.BuildResultHash = reader.ReadEncodedString(header.BuildResultHashOffset)
+
+        self.InstanceProviderData = ObjectInitializationData()
+        self.InstanceProviderData.ReadBinary(reader, header.InstanceProviderOffset)
+
+        self.SceneProviderData = ObjectInitializationData()
+        self.SceneProviderData.ReadBinary(reader, header.SceneProviderOffset)
+
+        resourceProviderDataOffsets = reader.ReadOffsetArray(
+            header.InitObjectsArrayOffset
+        )
+        self.ResourceProviderData = []
+        for i in range(len(resourceProviderDataOffsets)):
+            o = ObjectInitializationData()
+            o.ReadBinary(reader, resourceProviderDataOffsets[i])
+            self.ResourceProviderData.append(o)
+
+        self.ReadResourcesBinary(reader, header)
+
+    def ReadResourcesJson(self, data: ContentCatalogDataJson):
+        buckets: list[ContentCatalogData.Bucket] = []
+
+        bucketStream = BytesIO(b64decode(data.m_BucketDataString))
+        bucketReader = BinaryReader(bucketStream)
+        bucketCount = bucketReader.ReadInt32()
+        for i in range(bucketCount):
+            offset = bucketReader.ReadInt32()
+            entryCount = bucketReader.ReadInt32()
+            entries: list[int] = []
+            for j in range(entryCount):
+                entries.append(bucketReader.ReadInt32())
+            buckets.append(ContentCatalogData.Bucket(offset, entries))
+
+        keys: list[
+            ClassJsonObject
+            | TypeReference
+            | Hash128
+            | int
+            | str
+            | WrappedSerializedObject[AssetBundleRequestOptions]
+        ] = []
+
+        keyDataStream = BytesIO(b64decode(data.m_KeyDataString))
+        keyReader = BinaryReader(keyDataStream)
+        keyCount = keyReader.ReadInt32()
+        for i in range(keyCount):
+            keyDataStream.seek(buckets[i].offset)
+            keys.append(SerializedObjectDecoder.DecodeV1(keyReader))
+
+        locations: list[ResourceLocation] = []
+
+        entryDataStream = BytesIO(b64decode(data.m_EntryDataString))
+        extraDataStream = BytesIO(b64decode(data.m_ExtraDataString))
+        entryReader = BinaryReader(entryDataStream)
+        extraReader = BinaryReader(extraDataStream)
+        entryCount = entryReader.ReadInt32()
+        for i in range(entryCount):
+            internalIdIndex = entryReader.ReadInt32()
+            providerIndex = entryReader.ReadInt32()
+            dependencyKeyIndex = entryReader.ReadInt32()
+            depHash = entryReader.ReadInt32()
+            dataIndex = entryReader.ReadInt32()
+            primaryKeyIndex = entryReader.ReadInt32()
+            resourceTypeIndex = entryReader.ReadInt32()
+
+            internalId = self.InternalIds[internalIdIndex]
+            splitIndex = internalId.find("#")
+            if splitIndex != -1:
+                try:
+                    prefixIndex = int(internalId[:splitIndex])
+                    internalId = (
+                        self.InternalIdPrefixes[prefixIndex]
+                        + internalId[splitIndex + 1 :]
+                    )
+                except ValueError:
+                    pass
+
+            providerId = self.ProviderIds[providerIndex]
+
+            dependencyKey = (
+                keys[dependencyKeyIndex] if dependencyKeyIndex >= 0 else None
+            )
+
+            if dataIndex >= 0:
+                extraDataStream.seek(dataIndex)
+                objData = SerializedObjectDecoder.DecodeV1(extraReader)
+            else:
+                objData = None
+
+            if self.Keys is None:
+                primaryKey = keys[primaryKeyIndex]
+            else:
+                primaryKey = self.Keys[primaryKeyIndex]
+
+            resourceType = self.ResourceTypes[resourceTypeIndex]
+
+            loc = ResourceLocation()
+            loc.ReadJson(
+                internalId,
+                providerId,
+                dependencyKey,
+                objData,
+                depHash,
+                primaryKey,
+                resourceType,
+            )
+            locations.append(loc)
+
+        self.Resources = {}
+        for i in range(len(buckets)):
+            bucketEntries = buckets[i].entries
+            locs = []
+            for j in range(len(bucketEntries)):
+                locs.append(locations[bucketEntries[j]])
+            self.Resources[keys[i]] = locs
+
+    def ReadResourcesBinary(
+        self, reader: CatalogBinaryReader, header: ContentCatalogDataBinaryHeader
+    ):
+        keyLocationOffsets = reader.ReadOffsetArray(header.KeysOffset)
+        self.Resources = {}
+        for i in range(0, len(keyLocationOffsets), 2):
+            keyOffset = keyLocationOffsets[i]
+            locationListOffset = keyLocationOffsets[i + 1]
+            key = SerializedObjectDecoder.DecodeV2(reader, keyOffset)
+
+            locationOffsets = reader.ReadOffsetArray(locationListOffset)
+            locations = []
+            for j in range(len(locationOffsets)):
+                location = ResourceLocation()
+                location.ReadBinary(reader, locationOffsets[j])
+                locations.append(location)
+
+            self.Resources[key] = locations
+
+
+__all__ = ["ContentCatalogData"]

AddressablesTools/Catalog/ObjectInitializationData.py

@@ -0,0 +1,39 @@
+from .SerializedType import SerializedType
+from ..JSON.ObjectInitializationDataJson import ObjectInitializationDataJson
+from ..Reader.CatalogBinaryReader import CatalogBinaryReader
+
+
+class ObjectInitializationData:
+    Id: str | None
+    ObjectType: SerializedType | None
+    Data: str | None
+
+    def __repr__(self):
+        return (
+            f"<{self.__class__.__name__}(Id={self.Id}, ObjectType={self.ObjectType})>"
+        )
+
+    def __init__(self):
+        self.Id = None
+        self.ObjectType = None
+        self.Data = None
+
+    def ReadJson(self, obj: ObjectInitializationDataJson):
+        self.Id = obj.m_Id
+        self.ObjectType = SerializedType()
+        self.ObjectType.ReadJson(obj.m_ObjectType)
+        self.Data = obj.m_Data
+
+    def ReadBinary(self, reader: CatalogBinaryReader, offset: int):
+        reader.BaseStream.seek(offset)
+        idOffset = reader.ReadUInt32()
+        objectTypeOffset = reader.ReadUInt32()
+        dataOffset = reader.ReadUInt32()
+
+        self.Id = reader.ReadEncodedString(idOffset)
+        self.ObjectType = SerializedType()
+        self.ObjectType.ReadBinary(reader, objectTypeOffset)
+        self.Data = reader.ReadEncodedString(dataOffset)
+
+
+__all__ = ["ObjectInitializationData"]

AddressablesTools/Catalog/ResourceLocation.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from .SerializedType import SerializedType
+from .ClassJsonObject import ClassJsonObject
+from .SerializedObjectDecoder import SerializedObjectDecoder
+from ..Reader.CatalogBinaryReader import CatalogBinaryReader
+from ..Classes.TypeReference import TypeReference
+from ..Classes.Hash128 import Hash128
+from ..Classes.AssetBundleRequestOptions import AssetBundleRequestOptions
+from ..Catalog.WrappedSerializedObject import WrappedSerializedObject
+
+
+class ResourceLocation:
+    InternalId: str | None
+    ProviderId: str | None
+    DependencyKey: object
+    Dependencies: list[ResourceLocation] | None
+    Data: (
+        ClassJsonObject
+        | TypeReference
+        | Hash128
+        | int
+        | str
+        | bool
+        | WrappedSerializedObject[AssetBundleRequestOptions]
+        | None
+    )
+    HashCode: int
+    DependencyHashCode: int
+    PrimaryKey: str | None
+    Type: SerializedType | None
+
+    def __repr__(self):
+        return (
+            f"<{self.__class__.__name__}("
+            f"InternalId={self.InternalId}, "
+            f"ProviderId={self.ProviderId}, "
+            f"DependencyKey={self.DependencyKey}, "
+            f"Dependencies={self.Dependencies}, "
+            f"Data={self.Data}, "
+            f"HashCode={self.HashCode}, "
+            f"DependencyHashCode={self.DependencyHashCode}, "
+            f"PrimaryKey={self.PrimaryKey}, "
+            f"Type={self.Type}"
+            f")>"
+        )
+
+    def __init__(self):
+        self.InternalId = None
+        self.ProviderId = None
+        self.DependencyKey = None
+        self.Dependencies = None
+        self.Data = None
+        self.HashCode = 0
+        self.DependencyHashCode = 0
+        self.PrimaryKey = None
+        self.Type = None
+
+    def ReadJson(
+        self,
+        internalId: str | None,
+        providerId: str | None,
+        dependencyKey: object,
+        objData: (
+            ClassJsonObject
+            | TypeReference
+            | Hash128
+            | int
+            | str
+            | bool
+            | WrappedSerializedObject[AssetBundleRequestOptions]
+            | None
+        ),
+        depHash: int,
+        primaryKey: object,
+        resourceType: SerializedType | None,
+    ):
+        self.InternalId = internalId
+        self.ProviderId = providerId
+        self.DependencyKey = dependencyKey
+        self.Dependencies = None
+        self.Data = objData
+        self.HashCode = hash(self.InternalId) * 31 + hash(self.ProviderId)
+        self.DependencyHashCode = depHash
+        self.PrimaryKey = str(primaryKey)
+        self.Type = resourceType
+
+    def ReadBinary(self, reader: CatalogBinaryReader, offset: int):
+        reader.BaseStream.seek(offset)
+        primaryKeyOffset = reader.ReadUInt32()
+        internalIdOffset = reader.ReadUInt32()
+        providerIdOffset = reader.ReadUInt32()
+        dependenciesOffset = reader.ReadUInt32()
+        dependencyHashCode = reader.ReadInt32()
+        dataOffset = reader.ReadUInt32()
+        typeOffset = reader.ReadUInt32()
+
+        self.PrimaryKey = reader.ReadEncodedString(primaryKeyOffset, "/")
+        self.InternalId = reader.ReadEncodedString(internalIdOffset, "/")
+        self.ProviderId = reader.ReadEncodedString(providerIdOffset, ".")
+
+        dependenciesOffsets = reader.ReadOffsetArray(dependenciesOffset)
+        dependencies: list[ResourceLocation] = []
+        for i in range(len(dependenciesOffsets)):
+            objectOffset = dependenciesOffsets[i]
+            dependencyLocation = reader.ReadCustom(
+                objectOffset,
+                lambda: (x := ResourceLocation()).ReadBinary(reader, objectOffset) or x,
+            )
+            dependencies.append(dependencyLocation)
+
+        self.DependencyKey = None
+        self.Dependencies = dependencies
+
+        self.DependencyHashCode = dependencyHashCode
+        self.Data = SerializedObjectDecoder.DecodeV2(reader, dataOffset)
+        self.Type = SerializedType()
+        self.Type.ReadBinary(reader, typeOffset)
+
+
+__all__ = ["ResourceLocation"]