azlassets 3.3.0__py3-none-any.whl

azlassets/__init__.py

@@ -0,0 +1 @@
+__version__ = "3.3.0" # x-release-please-version

azlassets/classes.py

@@ -0,0 +1,191 @@
+from enum import Enum
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Self
+
+
+CompareType = Enum('CompareType', 'New Changed Unchanged Deleted')
+DownloadType = Enum('DownloadType', 'NoChange Removed Success Failed ForDeletionNoChange')
+
+class VersionType(Enum):
+	__hash2member_map__: dict[str, Self] = {}
+	hashname: str
+	"""Hash name used on the version result returned by the game server."""
+	suffix: str
+	"""Suffix used on version and hash files."""
+
+	AZL			= (1,	"azhash",		"")
+	CV			= (2,	"cvhash",		"cv")
+	L2D			= (3,	"l2dhash",		"live2d")
+	PIC			= (4,	"pichash",		"pic")
+	BGM			= (5,	"bgmhash",		"bgm")
+	CIPHER		= (6,	"cipherhash",	"cipher")
+	MANGA		= (7,	"mangahash",	"manga")
+	PAINTING	= (8,	"paintinghash",	"painting")
+	DORM		= (9,	"dormhash",		"dorm")
+	MAP			= (10,	"maphash",		"map")
+
+
+	def __init__(self, _, hashname, suffix) -> None:
+		# add attributes to enum objects
+		self.hashname = hashname
+		self.suffix = suffix
+		# add enum objects to member maps
+		self.__hash2member_map__[hashname] = self
+
+	def __str__(self) -> str:
+		return self.name.lower()
+
+	@property
+	def version_filename(self) -> str:
+		"""
+		Full version filename using the suffix.
+		"""
+		suffix = self.suffix
+		if suffix: suffix = "-"+suffix
+		return f"version{suffix}.txt"
+
+	@property
+	def hashes_filename(self) -> str:
+		"""
+		Full hashes filename using the suffix.
+		"""
+		suffix = self.suffix
+		if suffix: suffix = "-"+suffix
+		return f"hashes{suffix}.csv"
+
+	@classmethod
+	def from_hashname(cls, hashname: str) -> Self | None:
+		"""
+		Returns a VersionType member with matching *hashname* if match exists, otherwise None.
+		"""
+		return cls.__hash2member_map__.get(hashname)
+
+
+class AbstractClient(Enum):
+	active: bool
+	locale_code: str
+	package_name: str
+
+	def __new__(cls, value, active, locale, package_name):
+		# this should be done differently, but i am too lazy to do that now
+		# TODO: change it
+		if not hasattr(cls, "package_names"):
+			cls.package_names = {}
+
+		obj = object.__new__(cls)
+		obj._value_ = value
+		obj.active = active
+		obj.locale_code = locale
+		obj.package_name = package_name
+		cls.package_names[package_name] = obj
+		return obj
+
+	@classmethod
+	def from_package_name(cls, package_name) -> Self | None:
+		return cls.package_names.get(package_name)
+
+
+class Client(AbstractClient):
+	EN = (1, True, 'en-US', 'com.YoStarEN.AzurLane')
+	JP = (2, True, 'ja-JP', 'com.YoStarJP.AzurLane')
+	CN = (3, True, 'zh-CN', '')
+	KR = (4, True, 'ko-KR', 'kr.txwy.and.blhx')
+	TW = (5, True, 'zh-TW', 'com.hkmanjuu.azurlane.gp')
+
+
+@dataclass
+class HashRow:
+	filepath: str
+	size: int
+	md5hash: str
+
+@dataclass
+class CompareResult:
+	current_hash: HashRow | None
+	new_hash: HashRow | None
+	compare_type: CompareType
+
+@dataclass
+class VersionResult:
+	version: str
+	vhash: str
+	rawstring: str
+	version_type: VersionType
+
+@dataclass
+class BundlePath:
+	full: Path
+	inner: str
+
+	@staticmethod
+	def construct(parentdir: Path, inner: Path | str) -> "BundlePath":
+		fullpath = Path(parentdir, inner)
+		return BundlePath(fullpath, str(inner))
+
+	def __hash__(self):
+		return hash(self.inner)
+
+@dataclass
+class UpdateResult:
+	compare_result: CompareResult
+	download_type: DownloadType
+	path: BundlePath
+
+@dataclass
+class UserConfig:
+	useragent: str
+	download_isblacklist: bool
+	download_filter: list
+	extract_isblacklist: bool
+	extract_filter: list
+	asset_directory: Path
+	extract_directory: Path
+
+@dataclass
+class ClientConfig:
+	gateip: str
+	gateport: int
+	cdnurl: str
+
+
+# stolen from https://stackoverflow.com/questions/3173320/text-progress-bar-in-the-console
+def printProgressBar(iteration, total, prefix = '', suffix = 'Complete', decimals = 1, length = 50, fill = '█', printEnd = "\r", details_unit = None):
+	"""
+	Call in a loop to create terminal progress bar
+	@params:
+		iteration	- Required  : current iteration (Int)
+		total		- Required  : total iterations (Int)
+		prefix		- Optional  : prefix string (Str)
+		suffix		- Optional  : suffix string (Str)
+		decimals	- Optional  : positive number of decimals in percent complete (Int)
+		length		- Optional  : character length of bar (Int)
+		fill		- Optional  : bar fill character (Str)
+		printEnd	- Optional  : end character (e.g. "\r", "\r\n") (Str)
+	"""
+	percent = ("{0:." + str(decimals) + "f}").format(100 * (iteration / float(total)))
+	filledLength = int(length * iteration // total)
+	progress = fill * filledLength + '-' * (length - filledLength)
+	details = f" [{iteration}/{total} {details_unit}]" if details_unit else ""
+	print(f'\r{prefix} |{progress}| {percent}% {suffix}{details}', end = printEnd)
+	# Print New Line on Complete
+	if iteration == total:
+		print()
+
+# simplified progress bar class with only the useful stuff i use
+class ProgressBar():
+	def __init__(self, total: int, prefix: str, suffix: str = "Complete", iterstart: int = 0, details_unit: str | None = None, print_on_init: bool = True):
+		self.iteration = iterstart
+		self.total = total
+		self.prefix = prefix
+		self.suffix = suffix
+		self.details_unit = details_unit
+		if print_on_init:
+			printProgressBar(iterstart, total, prefix, suffix, details_unit=details_unit)
+
+	def update(self, iteration: int | None = None):
+		if iteration:
+			self.iteration = iteration
+		else:
+			self.iteration += 1
+		printProgressBar(self.iteration, self.total, self.prefix, self.suffix, details_unit=self.details_unit)

azlassets/config/client_config.json

@@ -0,0 +1,27 @@
+{
+	"EN": {
+		"gateip": "blhxusgate.yo-star.com",
+		"gateport": 80,
+		"cdnurl": "https://blhxusstatic.yo-star.com"
+	},
+	"CN": {
+		"gateip": "line1-login-bili-blhx.bilibiligame.net",
+		"gateport": 80,
+		"cdnurl": "https://line3-patch-blhx.bilibiligame.net"
+	},
+	"JP": {
+		"gateip": "blhxjploginapi.azurlane.jp",
+		"gateport": 80,
+		"cdnurl": "https://blhxstatic.yo-star.com"
+	},
+	"KR": {
+		"gateip": "bl-kr-gate.xdg.com",
+		"gateport": 80,
+		"cdnurl": "http://blcdn.imtxwy.com"
+	},
+	"TW": {
+		"gateip": "prod-all-login.azurlane.tw",
+		"gateport": 10080,
+		"cdnurl": "http://blhxstatic.azurlane.tw"
+	}
+}

azlassets/config/user_config_template.yml

@@ -0,0 +1,61 @@
+asset-directory: ClientAssets
+extract-directory: ClientExtract
+# set to blacklist or whitelist
+download-folder-listtype: blacklist
+extract-folder-listtype: whitelist
+download-folder-list: []
+extract-folder-list:
+- activitybanner
+- aircrafticon
+- backyardtheme
+- battlescore
+- bg
+- boxprefab
+- chargeicon
+- clutter
+- collectionfileillustration
+- collectionfiletitle
+- commanderhrz
+- commandericon
+- commanderskillicon
+- commandertalenticon
+- commonbg
+- crusingwindow
+- emblem
+- enemies
+- equips
+- eventtype
+- extra_page
+- furnitureicon
+- gallerycard
+- guildnode
+- guildboss
+- guildevent
+- guildmission
+- helpbg
+- herohrzicon
+- icondesc
+- iconframe
+- independenttex
+- levelmap
+- loadingbg
+- lotterybg
+- mangapic
+- medal
+- memoryicon
+- metaship
+- musiccover
+- newshipbg
+- newyearskinshowpage
+- painting
+- prints
+- props
+- qicon
+- shipmodels
+- shiprarity
+- shipyardicon
+- skillicon
+- squareicon
+- strategyicon
+- updatebg
+useragent: ''

azlassets/config.py

@@ -0,0 +1,62 @@
+import sys
+import json
+import yaml
+from shutil import copy
+from pathlib import Path
+from importlib.resources import files
+
+from .classes import Client, UserConfig, ClientConfig
+
+
+# package-incuded filepaths
+CONFIG_DATA_PATH = files("azlassets").joinpath("config")
+YAML_TEMPLATE_PATH = CONFIG_DATA_PATH.joinpath("user_config_template.yml")
+CLIENT_CONFIG_PATH = CONFIG_DATA_PATH.joinpath("client_config.json")
+
+# cwd-relative filepaths
+YAML_CONFIG_PATH = Path("config") / "user_config.yml"
+
+
+def load_user_config() -> UserConfig:
+	if not YAML_CONFIG_PATH.exists():
+		print("Userconfig does not exist. A new one will be created.")
+		print("Note that the useragent is empty and it is advised to set one.")
+		YAML_CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+		copy(YAML_TEMPLATE_PATH, YAML_CONFIG_PATH)
+		return load_user_config()
+
+	with open(YAML_CONFIG_PATH, 'r', encoding='utf8') as file:
+		yamlconfig = yaml.safe_load(file)
+
+	try:
+		userconfig = UserConfig(
+			useragent=yamlconfig['useragent'],
+			download_isblacklist=yamlconfig['download-folder-listtype'] == 'blacklist',
+			download_filter=yamlconfig['download-folder-list'],
+			extract_isblacklist=yamlconfig['extract-folder-listtype'] == 'blacklist',
+			extract_filter=yamlconfig['extract-folder-list'],
+			asset_directory=yamlconfig['asset-directory'],
+			extract_directory=yamlconfig['extract-directory'],
+		)
+	except KeyError:
+		print("There is an error inside the userconfig file. Delete it or change the wrong values.")
+		sys.exit(1)
+
+	return userconfig
+
+
+def load_client_config(client: Client) -> ClientConfig:
+	with open(CLIENT_CONFIG_PATH, 'r', encoding='utf8') as f:
+		configdata = json.load(f)
+
+	if not client.name in configdata:
+		raise NotImplementedError(f'Client {client.name} has not been configured yet.')
+
+	config = configdata[client.name]
+	try:
+		clientconfig = ClientConfig(config['gateip'], config['gateport'], config['cdnurl'])
+	except KeyError:
+		print("The clientconfig has been wrongly configured.")
+		sys.exit(1)
+
+	return clientconfig

azlassets/downloader.py

@@ -0,0 +1,61 @@
+import aiohttp
+import aiofile
+import traceback
+from pathlib import Path
+
+from .classes import VersionResult
+
+
+class AzurlaneAsyncDownloader(aiohttp.ClientSession):
+	def __init__(self, cdn_url: str, useragent: str):
+		base_url = f"{cdn_url}/android/"
+		limited_tcp_connector = aiohttp.TCPConnector(limit_per_host=6)
+		super().__init__(base_url=base_url, headers={"user-agent": useragent}, connector=limited_tcp_connector)
+
+	async def get_hashes(self, versionhash: str) -> aiohttp.ClientResponse:
+		return await self.get(f"hash/{versionhash}")
+
+	async def get_asset(self, filehash: str) -> aiohttp.ClientResponse:
+		return await self.get(f"resource/{filehash}")
+
+	async def download_hashes(self, version_result: VersionResult) -> str | None:
+		try:
+			async with await self.get_hashes(version_result.rawstring) as response:
+				response: aiohttp.ClientResponse
+				response.raise_for_status() # raises error on bad HTTP status
+
+				hashes = await response.text()
+				return hashes
+
+		except Exception as e:
+			print(f"ERROR: An unexpected error occured while downloading '{version_result.version_type.name}' hashfile.")
+			traceback.print_exception(type(e), e, e.__traceback__)
+			return
+
+	async def download_asset(self, filehash: str, save_destination: Path, expected_file_size: int) -> bool:
+		"""
+		Downloads the requested file using the session and saves it to 'save_destination' on disk.
+
+		Returns `True` if the operation was successful, otherwise `False`.
+		"""
+		try:
+			async with await self.get_asset(filehash) as response:
+				response: aiohttp.ClientResponse
+				response.raise_for_status() # raises error on bad HTTP status
+
+				# reject response if response size doesn't match expected size
+				response_size = response.content_length
+				if expected_file_size != response_size:
+					print(f"ERROR: Received asset '{filehash}' with target '{save_destination}' has wrong size ({response_size}/{expected_file_size}).")
+					return False
+
+				save_destination.parent.mkdir(parents=True, exist_ok=True)
+				async with aiofile.async_open(save_destination, "wb") as file:
+					async for chunk in response.content.iter_chunked(1024*16): # no idea what chuck size is best
+						await file.write(chunk)
+
+			return True
+		except Exception as e:
+			print(f"ERROR: An unexpected error occured while downloading '{filehash}' to '{save_destination}'.")
+			traceback.print_exception(type(e), e, e.__traceback__)
+			return False

azlassets/imgrecon.py

@@ -0,0 +1,38 @@
+import re
+from UnityPy import AssetsManager
+from UnityPy.enums import ClassIDType
+from PIL import Image
+
+
+VR = re.compile(r'v ')
+TR = re.compile(r'vt ')
+SR = re.compile(r' ')
+def recon(src, mesh):
+	sx, sy = src.size
+	c = map(SR.split, list(filter(TR.match, mesh))[1::2])
+	p = map(SR.split, list(filter(VR.match, mesh))[1::2])
+	c = [(round(float(a[1])*sx), round((1-float(a[2]))*sy)) for a in c]
+	p = [(-int(float(a[1])), int(float(a[2]))) for a in p]
+	my = max(y for x, y in p)
+	p = [(x, my-y) for x, y in p[::2]]
+	cp = [(l+r, p) for l, r, p in zip(c[::2], c[1::2], p)]
+	ox, oy = zip(*[(r-l+p, b-t+q) for (l, t, r, b), (p, q) in cp])
+	out = Image.new('RGBA', (max(ox), max(oy)))
+	for c, p in cp: out.paste(src.crop(c), p)
+	return out
+
+def load_mesh(filepath, require_name=None):
+	am = AssetsManager(filepath)
+	for obj in am.objects:
+		if obj.type == ClassIDType.Mesh:
+			objdata = obj.read()
+			if require_name and require_name != objdata.m_Name:
+				continue
+			data = objdata.export().splitlines()
+			return data
+
+def load_images(filepath: str):
+	am = AssetsManager(filepath)
+	for obj in am.objects:
+		if obj.type == ClassIDType.Texture2D:
+			yield obj, obj.read()

azlassets/proto/p10min_pb_pb2.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: p10min_pb.proto
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0fp10min_pb.proto\x12\x0f\x61zlassets.proto\"+\n\x08\x63s_10800\x12\r\n\x05state\x18\x01 \x02(\r\x12\x10\n\x08platform\x18\x02 \x02(\t\"\xce\x01\n\x08sc_10801\x12\x12\n\ngateway_ip\x18\x01 \x02(\t\x12\x14\n\x0cgateway_port\x18\x02 \x02(\r\x12\x0b\n\x03url\x18\x03 \x02(\t\x12\x0f\n\x07version\x18\x04 \x03(\t\x12\x10\n\x08proxy_ip\x18\x05 \x01(\t\x12\x12\n\nproxy_port\x18\x06 \x01(\r\x12\r\n\x05is_ts\x18\x07 \x02(\r\x12\x11\n\ttimestamp\x18\x08 \x02(\r\x12 \n\x18monday_0oclock_timestamp\x18\t \x02(\r\x12\x10\n\x08\x63\x64n_list\x18\n \x03(\t')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'p10min_pb_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  _globals['_CS_10800']._serialized_start=36
+  _globals['_CS_10800']._serialized_end=79
+  _globals['_SC_10801']._serialized_start=82
+  _globals['_SC_10801']._serialized_end=288
+# @@protoc_insertion_point(module_scope)

azlassets/protobuf.py

@@ -0,0 +1,116 @@
+import importlib
+import socket
+
+
+PROTOBUFS = {}
+def import_pb(pb: int, addname: str = ""):
+	module = importlib.import_module(f".p{pb}{addname}_pb_pb2", "azlassets.proto")
+	PROTOBUFS[pb] = module
+
+def import_pb_with_retry(pb: int):
+	try:
+		import_pb(pb)
+	except ModuleNotFoundError:
+		import_pb(pb, "min")
+
+class InvalidHeaderError(Exception): pass
+
+class BasicCommand:
+	def __init__(self, command_id: int, index: int=0):
+		pbpackage = command_id//1000
+		if pbpackage not in PROTOBUFS:
+			try:
+				import_pb_with_retry(pbpackage)
+			except ModuleNotFoundError:
+				print(f'Command Package {pbpackage} does not exist (From cmd={command_id}).')
+
+		pbpak = PROTOBUFS[pbpackage]
+		if hasattr(pbpak, 'cs_'+str(command_id)):
+			self.command_id = command_id
+			self.index = index
+			self.pb = getattr(pbpak, 'cs_'+str(command_id))()
+		elif hasattr(pbpak, 'sc_'+str(command_id)):
+			self.command_id = command_id
+			self.index = index
+			self.pb = getattr(pbpak, 'sc_'+str(command_id))()
+		else:
+			print(f'Command {command_id} is not registered.')
+
+
+ADV_HEADER_LEN = 7
+HEADER_LEN = 2
+HEADER_NOID_LEN = ADV_HEADER_LEN - HEADER_LEN
+
+def serialize_pb(basic_pb_command):
+	payload = bytearray(basic_pb_command.pb.SerializeToString())
+
+	header_bytes = ((len(payload) or 1) + HEADER_NOID_LEN).to_bytes(2, byteorder='big')
+	command_id_bytes = basic_pb_command.command_id.to_bytes(2, byteorder='big')
+	index_bytes = basic_pb_command.index.to_bytes(2, byteorder='big')
+
+	command_bytes = bytearray(ADV_HEADER_LEN)
+	command_bytes[0] = header_bytes[0]
+	command_bytes[1] = header_bytes[1]
+	command_bytes[3] = command_id_bytes[0]
+	command_bytes[4] = command_id_bytes[1]
+	command_bytes[5] = index_bytes[0]
+	command_bytes[6] = index_bytes[1]
+	command_bytes.extend(payload)
+	return command_bytes
+
+
+def deserialize_header(header_bytes):
+	if not header_bytes[2] == 0:
+		raise InvalidHeaderError('Received invalid header.')
+	payload_size = (header_bytes[0] << 8 | header_bytes[1]) - HEADER_NOID_LEN
+	command_id = header_bytes[3] << 8 | header_bytes[4]
+	index = header_bytes[5] << 8 | header_bytes[6]
+	return payload_size, command_id, index
+
+def deserialize_pb(command_id, index, payload_bytes):
+	basiccmd = BasicCommand(command_id)
+	if hasattr(basiccmd, 'pb'):
+		basiccmd.pb.ParseFromString(payload_bytes)
+		print(f'Successfully received cmd={command_id} with idx={index}.')
+		return basiccmd
+
+
+# PROTOBUF HELPER METHODS
+class ConnectionSocket(socket.socket):
+	def __init__(self, blocking=True):
+		super().__init__(socket.AF_INET, socket.SOCK_STREAM)
+		self.setblocking(blocking)
+
+	def disconnect(self):
+		self.close()
+
+	def send_command(self, commandid, index, **kwargs):
+		print(f"Sending Command {commandid}.")
+		command = BasicCommand(commandid, index)
+		for k, v in kwargs.items():
+			setattr(command.pb, k, v)
+		self.send(serialize_pb(command))
+
+	def recv_command(self):
+		header = self.recv_bytes(ADV_HEADER_LEN)
+		payload_size, command_id, index = deserialize_header(header)
+		payload = self.recv_bytes(payload_size)
+		return deserialize_pb(command_id, index, payload)
+
+	def recv_bytes(self, bytesize:int):
+		data = b''
+		while len(data) < bytesize:
+			data += self.recv(bytesize - len(data))
+		return data
+
+def get_version_response(gateip, gateport):
+	with ConnectionSocket() as socket:
+		socket.connect((gateip, gateport))
+		socket.send_command(
+			10800,
+			0,
+			state=21,
+			platform='0'
+		)
+		result = socket.recv_command()
+	return result

azlassets/repair.py

@@ -0,0 +1,98 @@
+import hashlib
+import itertools
+import aiofile
+import asyncio
+from pathlib import Path
+
+from . import downloader, updater, versioncontrol
+from .classes import HashRow, UserConfig, VersionResult, VersionType, UpdateResult, CompareType, DownloadType, ProgressBar
+
+
+async def execute_coro_with_progressbar(coro, progressbar: ProgressBar):
+	r = await coro
+	progressbar.update()
+	return r
+
+
+semaphore_concurrent_files = asyncio.Semaphore(5)
+
+async def calc_md5hash(filepath: Path, chunk_size: int = 65536) -> str:
+	md5 = hashlib.md5()
+	async with semaphore_concurrent_files:
+		async with aiofile.async_open(filepath, "rb") as f:
+			async for chunk in f.iter_chunked(chunk_size):
+				if chunk:
+					md5.update(chunk)
+	return md5.hexdigest()
+
+async def get_filedata(filepath: Path) -> tuple[str, int]:
+	if filepath.exists():
+		current_md5 = await calc_md5hash(filepath)
+		current_size = filepath.stat().st_size
+		return current_md5, current_size
+	else:
+		return "", 0
+
+async def hashrow_from_file(assetbasepath: Path, filepath: Path) -> HashRow:
+	current_md5, current_size = await get_filedata(filepath)
+	clean_filepath = str(filepath.relative_to(assetbasepath)).replace("\\", "/")
+	return HashRow(clean_filepath, current_size, current_md5)
+
+async def hashrow_from_relative_file(assetbasepath: Path, relative_filepath: Path) -> HashRow:
+	current_md5, current_size = await get_filedata(assetbasepath / relative_filepath)
+	return HashRow(relative_filepath, current_size, current_md5)
+
+async def hashrows_from_files(client_directory: Path) -> list[HashRow]:
+	assetbasepath = client_directory / "AssetBundles"
+	progressbar = ProgressBar(0, "File Progress", details_unit="files", print_on_init=False)
+	print("Loading list of all files... ", end="")
+	tasks = [execute_coro_with_progressbar(hashrow_from_file(assetbasepath, fp), progressbar) for fp in assetbasepath.rglob("*") if not fp.is_dir()]
+	progressbar.total = len(tasks)
+	print("Done")
+	print("Checking all files...")
+	return await asyncio.gather(*tasks)
+
+async def repair(cdnurl: str, userconfig: UserConfig, client_directory: Path) -> list[UpdateResult]:
+	current_hashes = await hashrows_from_files(client_directory)
+	expected_hashes = itertools.chain(*filter(lambda x: x is not None, [versioncontrol.load_hash_file(vtype, client_directory) for vtype in VersionType]))
+	comparison_results = updater.compare_hashes(current_hashes, expected_hashes)
+	async with downloader.AzurlaneAsyncDownloader(cdnurl, useragent=userconfig.useragent) as downloader_session:
+		update_results = await updater.update_assets(downloader_session, comparison_results, client_directory)
+	return update_results
+
+async def repair_hashfile(version_result: VersionResult, cdnurl: str, userconfig: UserConfig, client_directory: Path) -> list[UpdateResult]:
+	# read hashes that are stored in the local hash file
+	localhashes = versioncontrol.load_hash_file(version_result.version_type, client_directory)
+
+	async with downloader.AzurlaneAsyncDownloader(cdnurl, useragent=userconfig.useragent) as downloader_session:
+		# load newest hashes from the game server
+		serverhashes = await updater.download_and_parse_hashes(version_result, downloader_session, userconfig) or []
+		assetbasepath = client_directory / "AssetBundles"
+
+		# parse hashes from all files stored on disk, but only check files that are expected based on the new hashes
+		# this skips deletion on unneeded files
+		print("Generating hashes for all files on disk...")
+		progressbar = ProgressBar(len(serverhashes), "File Progress", details_unit="files")
+		diskhashes_tasks = [execute_coro_with_progressbar(hashrow_from_relative_file(assetbasepath, hrow.filepath), progressbar) for hrow in serverhashes]
+		diskhashes = await asyncio.gather(*diskhashes_tasks)
+
+		# compare localhashes to diskhashes to determine which files have already been successfully downloaded
+		compare_results_disk = updater.compare_hashes(localhashes, diskhashes)
+		update_results_disk = {comp_result.new_hash.filepath: UpdateResult(comp_result, DownloadType.Success, comp_result.new_hash.filepath) for comp_result in compare_results_disk[CompareType.Changed]}
+		update_results_disk.update({comp_result.new_hash.filepath: UpdateResult(comp_result, DownloadType.Success, comp_result.new_hash.filepath) for comp_result in compare_results_disk[CompareType.New]})
+		update_results_disk.update({comp_result.current_hash.filepath: UpdateResult(comp_result, DownloadType.Removed, comp_result.current_hash.filepath) for comp_result in compare_results_disk[CompareType.Deleted]})
+
+		# download remaining files
+		update_results_server = await updater._update_from_hashes(version_result, downloader_session, client_directory, diskhashes, serverhashes, allow_deletion=False)
+
+		# add old update results to new update results list
+		update_results = []
+		for upres_server in update_results_server:
+			update_result = upres_server
+			# try to retrieve from old list only if there was no further change to the file
+			if upres_server.download_type == DownloadType.NoChange:
+				if upres_disk := update_results_disk.get(upres_server.path):
+					update_result = upres_disk
+			update_results.append(update_result)
+
+	return update_results