addressablestools 0.1.0__tar.gz

addressablestools-0.1.0/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

addressablestools-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: addressablestools
+Version: 0.1.0
+Summary: Python copy of AddressablesTools
+Author-email: Jitsu <jitsu233@gmail.com>
+License: Copyright (c) 2018 The Python Packaging Authority
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Homepage, https://github.com/anosu/AddressablesToolsPy
+Project-URL: Bug Reports, https://github.com/anosu/AddressablesToolsPy/issues
+Project-URL: Funding, https://donate.pypi.org
+Project-URL: Source, https://github.com/anosu/AddressablesToolsPy
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# AddressablesToolsPy
+
+Python copy of AddressablesTools
+
+### Usage
+
+```python
+from pathlib import Path
+from AddressablesTools import parse
+
+
+def main():
+    data = Path("tests/samples/catalog.json").read_text("utf-8")
+    catalog = parse(data)
+    for key, locs in catalog.Resources.items():
+        if not isinstance(key, str):
+            continue
+        if not key.endswith(".bundle"):
+            continue
+        res_loc = locs[0]
+        print(
+            f"Bundle {key}, Crc: {res_loc.Data.Object.Crc}, Hash: {res_loc.Data.Object.Hash}"
+        )
+
+    print("-" * 50)
+
+    asset_locs = catalog.Resources[
+        "Assets/Paripari/AddressableAssets/VFX Texture Assets/ParticleTextures/sparkle.png"
+    ]
+    dep_key = asset_locs[0].DependencyKey
+    print(f"Dependency of {asset_locs[0].PrimaryKey}: {dep_key}")
+    dep_bundle = catalog.Resources[dep_key][0]
+    print(f"ProviderId of {dep_bundle.PrimaryKey}: {dep_bundle.ProviderId}")
+    print(f"InternalId of {dep_bundle.PrimaryKey}: {dep_bundle.InternalId}")
+
+
+if __name__ == "__main__":
+    main()
+```

addressablestools-0.1.0/README.md

@@ -0,0 +1,39 @@
+# AddressablesToolsPy
+
+Python copy of AddressablesTools
+
+### Usage
+
+```python
+from pathlib import Path
+from AddressablesTools import parse
+
+
+def main():
+    data = Path("tests/samples/catalog.json").read_text("utf-8")
+    catalog = parse(data)
+    for key, locs in catalog.Resources.items():
+        if not isinstance(key, str):
+            continue
+        if not key.endswith(".bundle"):
+            continue
+        res_loc = locs[0]
+        print(
+            f"Bundle {key}, Crc: {res_loc.Data.Object.Crc}, Hash: {res_loc.Data.Object.Hash}"
+        )
+
+    print("-" * 50)
+
+    asset_locs = catalog.Resources[
+        "Assets/Paripari/AddressableAssets/VFX Texture Assets/ParticleTextures/sparkle.png"
+    ]
+    dep_key = asset_locs[0].DependencyKey
+    print(f"Dependency of {asset_locs[0].PrimaryKey}: {dep_key}")
+    dep_bundle = catalog.Resources[dep_key][0]
+    print(f"ProviderId of {dep_bundle.PrimaryKey}: {dep_bundle.ProviderId}")
+    print(f"InternalId of {dep_bundle.PrimaryKey}: {dep_bundle.InternalId}")
+
+
+if __name__ == "__main__":
+    main()
+```

addressablestools-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "addressablestools"
+version = "0.1.0"
+authors = [{ name = "Jitsu", email = "jitsu233@gmail.com" }]
+description = "Python copy of AddressablesTools"
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.12"
+dependencies = []
+
+[project.urls]
+"Homepage" = "https://github.com/anosu/AddressablesToolsPy"
+"Bug Reports" = "https://github.com/anosu/AddressablesToolsPy/issues"
+"Funding" = "https://donate.pypi.org"
+"Source" = "https://github.com/anosu/AddressablesToolsPy"
+
+[dependency-groups]
+dev = ["pytest>=8.3.5", "ruff>=0.11.7"]

addressablestools-0.1.0/setup.cfg

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

addressablestools-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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"]