feat: extract files into seperate subfolder using version as name

feat: automatically extract linked versions
feat: allow path based extraction using absolute filepaths

Author: nobbyfix

README.md

@@ -70,7 +70,9 @@ azl extract [CLIENT]
 
 Where `CLIENT` is one of EN, CN, JP, KR or TW. Extracted images will be saved in `ClientExtract/[CLIENT]/`. Since only Texture2D assets are exported, it's not desired to try to export from all assetbundles (See [settings section](#settings)).
 
-A single assetbundle can be extracted by passing the filepath to the script:
+Using the `-f` or `--filepath` a path for extraction can be passed to the program:
 ```bash
 azl extractor -f [FILEPATH]
 ```
+
+The path can be either to a single assetbundle or a directory. In the case of a directory, all subdiretories will be recursively extracted as well. The path can be either be an absolute path, or a relative path which needs to be relative to the `AssetBundles` directory of a client.

src/azl.py

@@ -78,19 +78,10 @@ def add_subparser_download(parser):
 
 def add_subparser_extract(parser):
 	extract_parser = parser.add_parser("extract", help="Extract image assets as pngs")
-	extract_parser.add_argument("client", type=str, choices=Client.__members__, help="client to extract files of")
+	extract_parser.add_argument("client", nargs="?", type=str, choices=Client.__members__, help="client to extract files of")
 	extract_parser.add_argument(
 		"-f", "--filepath", type=str, help="Path to the file or directly to extract only single file or all directory content"
 	)
-	extract_parser.add_argument(
-		"-v", "--version", type=str, help="Extract files of a specific version (Currently only applies to AZL Versiontype!)"
-	)
-	extract_parser.add_argument(
-		"-u",
-		"--until-version",
-		type=str,
-		help="Extract files from the latest until a specific version (Currently only applies to AZL Versiontype!)",
-	)
 
 
 def add_subparser_import(parser):

src/azlassets/classes.py

@@ -1,3 +1,4 @@
+from collections.abc import Callable
 from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
@@ -126,33 +127,36 @@ def from_package_name(cls, package_name: str) -> Self | None:
 		return cls.__package_name_map__.get(package_name)
 
 
-@dataclass
+@dataclass(eq=True, frozen=True)
 class HashRow:
 	filepath: str
 	size: int
 	md5hash: str
 
 
-@dataclass
+@dataclass(eq=True)
 class CompareResult:
 	current_hash: HashRow | None
 	new_hash: HashRow | None
 	compare_type: CompareType
 
 
-@dataclass
+@dataclass(eq=True, frozen=True)
 class SimpleVersionResult:
 	version: str
 	version_type: VersionType
 
+	def __str__(self):
+		return f"{self.version_type.name} {self.version}"
 
-@dataclass
+
+@dataclass(eq=True, frozen=True)
 class VersionResult(SimpleVersionResult):
 	vhash: str
 	rawstring: str
 
 
-@dataclass
+@dataclass(eq=True)
 class BundlePath:
 	full: Path
 	inner: str
@@ -170,7 +174,7 @@ def construct(parentdir: Path, inner: Path | str) -> "BundlePath":
 			BundlePath: The constructed BundlePath object
 		"""
 		fullpath = Path(parentdir, inner)
-		return BundlePath(fullpath, str(inner))
+		return BundlePath(fullpath, str(inner).replace("\\", "/"))
 
 	def __hash__(self):
 		return hash(self.inner)
@@ -221,6 +225,12 @@ def add_linked_version(self, version: SimpleVersionResult):
 		if version.version not in self.linked_versions[version.version_type]:
 			self.linked_versions[version.version_type].append(version.version)
 
+	def get_success_files(self, filter: Callable[[CompareType], bool] = (lambda *args, **kwargs: True)) -> list[BundlePath]:
+		return [bpath for bpath, ctype in self.success_files.items() if filter(ctype)]
+
+	def get_failed_files(self, filter: Callable[[CompareType], bool] = (lambda *args, **kwargs: True)) -> list[BundlePath]:
+		return [bpath for bpath, ctype in self.failed_files.items() if filter(ctype)]
+
 	def to_json(self) -> dict[str, Any]:
 		"""
 		Convert this DiffLog to a JSON-serialisable dict.
@@ -248,28 +258,28 @@ def to_json(self) -> dict[str, Any]:
 		return data
 
 	@staticmethod
-	def from_json(diffdata: dict[str, Any], vtype: VersionType, client_directory: Path):
+	def from_json(diffdata: dict[str, Any], vtype: VersionType, client_asset_directory: Path):
 		"""
 		Construct a DiffLog object from JSON data.
 
 		Args:
 			diffdata: Dict produced by :meth:``to_json``
 			vtype: The VersionType that owns this log
-			client_directory: Root client directory
+			client_asset_directory: Root client directory
 
 		Returns:
 			DiffLog: The constructed DiffLog object
 		"""
 		version = SimpleVersionResult(version=diffdata["version"], version_type=vtype)
 		major = diffdata.get("major", False)
 		linked_versions = {VersionType[vt_str]: versions for vt_str, versions in diffdata.get("linked_versions", {}).items()}
-		assetbasepath = Path(client_directory, "AssetBundles")
+		client_assetbundle_directory = Path(client_asset_directory, "AssetBundles")
 		success_files = {
-			BundlePath.construct(assetbasepath, path_str): CompareType[ctype]
+			BundlePath.construct(client_assetbundle_directory, path_str): CompareType[ctype]
 			for path_str, ctype in diffdata.get("success_files", {}).items()
 		}
 		failed_files = {
-			BundlePath.construct(assetbasepath, path_str): CompareType[ctype]
+			BundlePath.construct(client_assetbundle_directory, path_str): CompareType[ctype]
 			for path_str, ctype in diffdata.get("failed_files", {}).items()
 		}
 

src/azlassets/downloadmgr.py

@@ -86,7 +86,7 @@ async def execute(args):
 					versioncontroller.set_as_linked(vresult, azl_current)
 
 	if args.extract:
-		extractor.extract_by_client(args.client)
+		extractor.extract_latest_client(args.client)
 
 
 def execute_from_args(args):