azurpaint 1.0.0__tar.gz

azurpaint-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Fernando
+
+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.

azurpaint-1.0.0/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.1
+Name: azurpaint
+Version: 1.0.0
+Summary: Azur Lane painting reconstructor/extractor.
+Author-email: Fernando <81207411+Fernando2603@users.noreply.github.com>
+License: MIT License
+        
+        Copyright (c) 2024 Fernando
+        
+        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/Fernando2603/azurpaint
+Project-URL: Bug Tracker, https://github.com/Fernando2603/azurpaint/issues
+Keywords: python,unity,azurlane,azur-lane,extractor
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Multimedia :: Graphics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pillow
+Requires-Dist: UnityPy==1.10.6
+
+# azurpaint
+
+[![PyPI supported Python versions](https://img.shields.io/pypi/pyversions/azurpaint.svg)](https://pypi.python.org/pypi/azurpaint)
+[![MIT](https://img.shields.io/github/license/Fernando2603/azurpaint)](https://github.com/Fernando2603/azurpaint/blob/main/LICENSE)
+
+
+Azur Lane painting reconstructor/extractor.
+
+## Install
+**Python 3.9.0 or higher is required**
+```cmd
+pip install azurpaint
+```
+
+## Usage
+
+Simple example to extract painting
+
+- create new folder
+- get and extract `/Android/obb/com.YoStarEN.AzurLane/*.obb` to new folder
+- copy `AssetBundles` from `/Android/data/com.YoStarEN.AzurLane/files/AssetBundles`
+
+> [!NOTE]
+> only `painting`, `paintings` and `paintingface` folder are required from `AssetBundles`.
+
+
+```Python
+from pathlib import Path
+from azurpaint import Azurpaint
+from azurpaint.exception import PrefabNotFound
+
+# extract painting with default expression/face
+def extract(asset_bundle_path, prefab_path):
+  try:
+    azurpaint = Azurpaint(asset_bundle_path, prefab_path)
+
+    # search dependencies automatically within AssetBundles (root)
+    # this is still in experimental mode so far on testing the result is good
+    # load_dependencies only searching in local file and it doesn't know
+    # if there any missing dependency it doesn't know what file it is
+    # so you should provide complete asset include extracted OBB before running this
+    azurpaint.load_dependencies()
+
+    # PIL.Image.Image
+    return azurpaint.create()
+  except PrefabNotFound:
+    print(f"{prefab_path} is not an prefab.")
+
+
+# extract painting with all face/expression into output_dir
+def extract_all_face(asset_bundle_path, prefab_path, output_dir):
+  try:
+    azurpaint = Azurpaint(asset_bundle_path, prefab_path)
+    azurpaint.load_dependencies()
+
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    azurpaint.create().save(Path(output_dir, f"{azurpaint.prefab.name}-default.png"))
+
+    for face in azurpaint.face_list:
+      azurpaint.change_face(face)
+      azurpaint.create().save(Path(output_dir, f"{azurpaint.prefab.name}-{face}.png"))
+
+  except PrefabNotFound:
+    print(f"{prefab_path} is not an prefab.")
+
+
+if __name__ == '__main__':
+  # azurpaint require asset that have .prefab
+  # will raise PrefabNotFound if file is not an prefab
+  extract('path_to/AssetBundles', 'painting/tashigan')
+```

azurpaint-1.0.0/README.md

@@ -0,0 +1,71 @@
+# azurpaint
+
+[![PyPI supported Python versions](https://img.shields.io/pypi/pyversions/azurpaint.svg)](https://pypi.python.org/pypi/azurpaint)
+[![MIT](https://img.shields.io/github/license/Fernando2603/azurpaint)](https://github.com/Fernando2603/azurpaint/blob/main/LICENSE)
+
+
+Azur Lane painting reconstructor/extractor.
+
+## Install
+**Python 3.9.0 or higher is required**
+```cmd
+pip install azurpaint
+```
+
+## Usage
+
+Simple example to extract painting
+
+- create new folder
+- get and extract `/Android/obb/com.YoStarEN.AzurLane/*.obb` to new folder
+- copy `AssetBundles` from `/Android/data/com.YoStarEN.AzurLane/files/AssetBundles`
+
+> [!NOTE]
+> only `painting`, `paintings` and `paintingface` folder are required from `AssetBundles`.
+
+
+```Python
+from pathlib import Path
+from azurpaint import Azurpaint
+from azurpaint.exception import PrefabNotFound
+
+# extract painting with default expression/face
+def extract(asset_bundle_path, prefab_path):
+  try:
+    azurpaint = Azurpaint(asset_bundle_path, prefab_path)
+
+    # search dependencies automatically within AssetBundles (root)
+    # this is still in experimental mode so far on testing the result is good
+    # load_dependencies only searching in local file and it doesn't know
+    # if there any missing dependency it doesn't know what file it is
+    # so you should provide complete asset include extracted OBB before running this
+    azurpaint.load_dependencies()
+
+    # PIL.Image.Image
+    return azurpaint.create()
+  except PrefabNotFound:
+    print(f"{prefab_path} is not an prefab.")
+
+
+# extract painting with all face/expression into output_dir
+def extract_all_face(asset_bundle_path, prefab_path, output_dir):
+  try:
+    azurpaint = Azurpaint(asset_bundle_path, prefab_path)
+    azurpaint.load_dependencies()
+
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    azurpaint.create().save(Path(output_dir, f"{azurpaint.prefab.name}-default.png"))
+
+    for face in azurpaint.face_list:
+      azurpaint.change_face(face)
+      azurpaint.create().save(Path(output_dir, f"{azurpaint.prefab.name}-{face}.png"))
+
+  except PrefabNotFound:
+    print(f"{prefab_path} is not an prefab.")
+
+
+if __name__ == '__main__':
+  # azurpaint require asset that have .prefab
+  # will raise PrefabNotFound if file is not an prefab
+  extract('path_to/AssetBundles', 'painting/tashigan')
+```

azurpaint-1.0.0/azurpaint/__init__.py

@@ -0,0 +1,6 @@
+__version__ = '1.0.0'
+
+from .main import Azurpaint
+from .exception import *
+from .types import *
+from .lib import Inspector, Tree, Node

azurpaint-1.0.0/azurpaint/classes/AABB.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from .Vector2 import Vector2
+
+
+class AABB:
+  center: Vector2
+  extend: Vector2
+
+  def __init__(self, center: Vector2, extend: Vector2) -> None:
+    self.center = center
+    self.extend = extend
+
+
+  def __repr__(self) -> str:
+    return f"<{self.__class__.__name__} center={self.center.values()} extend={self.extend.values()}>"
+
+
+  @property
+  def padding(self) -> Vector2:
+    return self.center - self.extend
+
+
+  @property
+  def size(self) -> Vector2:
+    return self.center + self.extend

azurpaint-1.0.0/azurpaint/classes/AssetReader.py

@@ -0,0 +1,259 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Iterable, List, Optional, Set, Tuple, Union, cast
+from pathlib import Path
+from UnityPy import Environment, classes
+from UnityPy.enums import ClassIDType
+from UnityPy.files import ObjectReader
+
+from ..types import PathLike
+from ..exception import PrefabNotFound
+
+
+class AssetReader:
+  """
+    Read UnityAsset using UnityPy.
+  """
+  path: Path
+  prefab: Path
+  environment: Environment
+  files: List[str] = []
+  face: Dict[str, int]
+
+  def __init__(self, path: PathLike, prefab: PathLike) -> None:
+    self.face = {}
+    self.path = Path(path)
+    self.prefab = Path(prefab)
+
+    if not self.filepath.exists():
+      raise FileNotFoundError(f"File {self.filepath.as_posix()!r} not exists.")
+
+    self.environment = Environment(self.filepath.as_posix())
+    self.files.append(self.prefab.as_posix())
+
+    if not self.has_prefab:
+      raise PrefabNotFound(f"Prefab {self.prefab.as_posix()!r} not exists.")
+
+
+  def __repr__(self) -> str:
+    return f"<{self.__class__.__name__} prefab={self.prefab.as_posix()}>"
+
+
+  @property
+  def root(self) -> classes.GameObject:
+    return self.get_object_by_path_id(next(iter(self.environment.container.values())).path_id)
+
+
+  @property
+  def filepath(self) -> Path:
+    return Path(self.path, self.prefab)
+
+
+  @property
+  def has_prefab(self) -> bool:
+    try:
+      return any(key.endswith('.prefab') for key in self.environment.container.keys())
+    except:
+      return False
+
+
+  @property
+  def cabs(self) -> List[str]:
+    return list(k for k in self.environment.cabs.keys() if not k.endswith('.ress'))
+
+
+  @property
+  def dependencies(self) -> List[str]:
+    assets: classes.AssetBundle = self.get_object_by_path_id(1)
+    
+    if not hasattr(assets, 'm_Dependencies'):
+      raise ValueError(f"Prefab {self.prefab.as_posix()} is missing 'AssetBundle.m_Dependencies'.")
+
+    return cast(List[str], assets.m_Dependencies)
+
+
+  def get_cabs(self, name: PathLike) -> List[str]:
+    environment = Environment(Path(name).as_posix())
+    return list(k for k in environment.cabs.keys() if not k.endswith('.ress'))
+
+
+  def load(self, path: PathLike, is_face: bool = False) -> Path:
+    path = Path(path)
+
+    if not path.is_relative_to(self.path):
+      path = Path(self.path, path)
+
+    # is_dependencies is not used, it's a bit complicated with azurlane assets
+    # since some asset like paintingface is not an direct dependency for a lot ship
+    self.environment.load_file(path.as_posix())
+    self.files.append(path.relative_to(self.path).as_posix())
+
+    if is_face or path.is_relative_to(Path(self.path, 'paintingface')):
+      self.face = self._get_face(path)
+
+    return path
+
+
+  def loads(self, path: Union[PathLike, Iterable[PathLike]]) -> List[Path]:
+    if not isinstance(path, Iterable) or isinstance(path, str):
+      path = [path]
+
+    _loaded = []
+
+    for link in path:
+      _loaded.append(self.load(link))
+
+    return _loaded
+
+
+  def _gather_files(self, folders: List[str] = ['painting', 'paintings', 'paintingface']) -> List[str]:
+    """
+      Get all files list that have same name as prefab in painting, paintings and paintingface
+    """
+    files: List[str] = []
+
+    for folder in folders:
+      glob = Path(self.path, folder).glob(f"{self.prefab.name.split('_')[0]}*")
+      files.extend([file.relative_to(self.path).as_posix() for file in glob])
+
+    return files
+
+
+  def _get_face(self, path: Path) -> Dict[str, int]:
+    face = {}
+
+    for obj in cast(List[ObjectReader], self.environment.files[path.as_posix()].get_objects()):
+      if obj.type != ClassIDType.Sprite:
+        continue
+
+      obj = cast(classes.Sprite, obj.read())
+      face[obj.name] = obj.path_id
+
+    return {key: face[key] for key in sorted(face.keys())}
+
+
+
+  def _load_face(self, force: bool = True) -> None:
+    if len(self.face):
+      return
+
+    files = self._gather_files(['paintingface'])
+    prefab_face = Path('paintingface', self.prefab.name).as_posix()
+
+    if prefab_face in files:
+      self.load(prefab_face, is_face=True)
+      return
+
+    if not force:
+      return
+
+    # face not found or not same as prefab name
+    # sometimes face have different name with underscore extension 
+    # but still have same basename eg like _hx extension
+    # this is not perfect it may load wrong face
+    possible_name: List[str] = [prefab_face]
+
+    while '_' in prefab_face:
+      prefab_face = prefab_face.rsplit('_', 1)[0]
+      possible_name.append(prefab_face)
+
+    matches: List[str] = [file for file in files if file in possible_name]
+
+    if len(matches) == 0:
+      return
+
+    # when matches is more than one. probably the longest is more desired one
+    # since it splitted with underscore so we're prefer longer string
+    self.load(max(matches, key=len), is_face=True)
+
+
+  def find_dependencies(self) -> Tuple[Set[str], Set[str]]:
+    """
+      Find all dependencies in loaded path
+
+      :returns: tuple[`result`, `missing_dependencies`]
+    """
+    result: Set[str] = set()
+    dependencies: Set[str] = set(self.dependencies)
+
+    if not len(dependencies):
+      return result, dependencies
+
+    files: List[str] = self._gather_files()
+
+    # blank image used by asset to create canvas
+    files.append('painting/touming_tex')
+
+    for file in files:
+      if not len(dependencies):
+        break
+
+      for cab in self.get_cabs(Path(self.path, file)):
+        if cab in dependencies:
+          result.add(file)
+          dependencies.remove(cab)
+
+    return result, dependencies
+
+
+  def load_dependencies(self, force_face_load: bool = False) -> None:
+    """
+      Automatically search for dependencies by name.
+
+      :params force_face_load: force load face with matching name
+
+      Warning
+      -------
+      This is still in experimental state, undefined behaviour may occurs.
+    """
+    dependencies, _ = self.find_dependencies()
+
+    if not len(self.face):
+      self._load_face(force=force_face_load)
+
+    self.loads(dependencies)
+
+
+  def get_object_by_path_id(self, path_id: int) -> Any:
+    for obj in self.environment.objects:
+      if obj.path_id == path_id:
+        return cast(Any, obj.read(return_typetree_on_error=False))
+
+
+  def get_object_by_name(self, name: str, type: ClassIDType) -> Any:
+    for obj in self.environment.objects:
+      try:
+        if not hasattr(obj, 'name') or (obj.type != type):
+          continue
+
+        obj = cast(Any, obj.read(return_typetree_on_error=False))
+
+        if hasattr(obj, 'name') and (str(obj.name) == str(name)):
+          return obj
+
+      except:
+        continue
+
+
+  def get_component_from_object(
+    self,
+    gameobject: classes.GameObject,
+    types: Optional[Iterable[ClassIDType]] = None,
+    names: Optional[Set[str]] = None,
+    attributes: Optional[Set[str]] = None
+  ) -> Any:
+    for component_pptr in cast(List[classes.PPtr], gameobject.m_Components):
+      if types and (not component_pptr.type in types):
+        continue
+
+      component = self.get_object_by_path_id(component_pptr.path_id)
+
+      if names and (not component.name in names):
+        continue
+
+      if attributes:
+        for attribute in attributes:
+          if hasattr(component, attribute):
+            return component
+
+      return component