Ejemplo n.º 1
0
 def download_index(self, asset_id):
     '''
     Downloads the JSON asset index specified by 'asset_id'
     '''
     asset_url_object = URL("indexes/" + asset_id + ".json", URL.DOWNLOAD).url_object()
     asset_index_path = str(self.BASE_PATH.joinpath("indexes/" + asset_id + ".json"))
     FileTools.write_object(asset_index_path, asset_url_object)
Ejemplo n.º 2
0
    def download_missing(self, asset_id, progress_function=None):
        '''
        Downloads assets specified in 'asset_id' that are not already downloaded
        '''
        asset_info = FileTools.read_json(str(self.get_paths(asset_id)["index"]))
        asset_list = asset_info["objects"]

        if not (progress_function == None):
            progress_function("Finding missing assets", 0)
        asset_dict = dict()
        if (self._is_virtual(asset_info)):
            assets_base_path = self.BASE_PATH.joinpath("virtual/" + asset_id)
            if not assets_base_path.exists():
                for asset_name in asset_list.keys():
                    asset_url = URL([asset_list[asset_name]["hash"][:2], asset_list[asset_name]["hash"]], URL.RESOURCES)
                    asset_dict[asset_url] = str(assets_base_path.joinpath(asset_name))
        else:
            for asset in asset_list.values():
                asset_relative_path = [asset["hash"][:2], asset["hash"]]
                asset_url = URL(asset_relative_path, URL.RESOURCES)
                asset_path = self.BASE_PATH.joinpath(*(["objects"] + asset_relative_path))
                if not asset_path.exists():
                    asset_dict[asset_url] = str(asset_path)

        asset_count = 0
        asset_total_count = len(asset_dict)
        for asset_url in asset_dict.keys():
            asset_url_object = asset_url.url_object()
            FileTools.write_object(asset_dict[asset_url], asset_url_object)
            asset_count += 1
            if not (progress_function == None):
                progress_function("Downloading assets", asset_count/asset_total_count)
Ejemplo n.º 3
0
 def _file_exists(self, name, file_path):
     if FileTools.exists(file_path):
         if FileTools.is_file(file_path):
             return True
         else:
             QtGui.QMessageBox.critical(self, "YAMCL: " + name + " Path Error", name + " path '" + file_path + "' is not a regular file.")
             return False
     else:
         QtGui.QMessageBox.critical(self, "YAMCL: " + name + " Path Error", name + " path '" + file_path + "' does not exist.")
Ejemplo n.º 4
0
 def delete(self, profile_name):
     '''
     Deletes profile 'profile_name'
     '''
     if not profile_name in self.index:
         raise Exception("Profile " + str(profile_name) + " does not exist") # TODO: More appropriate exception
     FileTools.delete_and_clean(str(self.BASE_PATH.joinpath(*self.index[profile_name]["directory"])))
     del self.index[profile_name]
     self._flush_index()
Ejemplo n.º 5
0
 def _dir_exists(self, name, dir_path):
     if FileTools.exists(dir_path):
         if FileTools.is_dir(dir_path):
             return True
         else:
             QtGui.QMessageBox.critical(self, "YAMCL: " + name + " Path Error", name + " path '" + dir_path + "' is not a directory.")
             return False
     else:
         QtGui.QMessageBox.critical(self, "YAMCL: " + name + " Path Error", name + " path '" + dir_path + "' does not exist.")
Ejemplo n.º 6
0
 def new(self, profile_name):
     '''
     Creates a new profile with name 'profile_name'
     '''
     if not profile_name in self.index:
         self.index[profile_name] = dict()
         self.index[profile_name]["directory"] = [FileTools.create_valid_name(profile_name)]
         profile_metadata = dict()
         FileTools.write_json(str(self.BASE_PATH.joinpath(profile_name + "/yamcl_metadata.json")), profile_metadata)
         self._flush_index()
Ejemplo n.º 7
0
 def delete(self, version_id, version_type):
     if not self.version_exists(version_id, version_type):
         raise Exception("Version does not exist") # TODO: More appropriate exception
     index_count = 0
     for current_version in self.index:
         if current_version["type"] == version_type and current_version["name"] == version_id:
             break
         else:
             index_count += 1
     del self.index[index_count]
     self._flush_index()
     FileTools.delete_and_clean(str(self.get_paths(version_id, version_type)["directory"]))
Ejemplo n.º 8
0
    def _clone_version(self, orig_id, orig_type, clone_id, clone_type):
        orig_paths = self.get_paths(orig_id, orig_type)
        clone_paths = self.get_paths(clone_id, clone_type)
        FileTools.copy(orig_paths["jar"], clone_paths["jar"])
        FileTools.copy(orig_paths["json"], clone_paths["json"])

        current_listing = dict()
        current_listing["type"] = clone_type
        current_listing["name"] = clone_id

        self.index.append(current_listing)

        self._flush_index()
Ejemplo n.º 9
0
 def rename(self, current_profile_name, new_profile_name):
     '''
     Renames a profile 'current_profile_name' to a new name 'new_profile_name'
     '''
     if not current_profile_name in self.index:
         raise Exception("Cannot rename: " + current_profile_name + " does not exist")
     if new_profile_name in self.index:
         raise Exception("Cannot rename: " + new_profile_name + " already exists")
     FileTools.rename(str(self.BASE_PATH.joinpath(*self.index[current_profile_name]["directory"])), str(self.BASE_PATH.joinpath(FileTools.create_valid_name(new_profile_name))))
     del self.index[current_profile_name]
     self.index[new_profile_name] = dict()
     self.index[new_profile_name]["directory"] = [FileTools.create_valid_name(new_profile_name)]
     self._flush_index()
Ejemplo n.º 10
0
    def install_custom(self, version_id, version_jar, version_json):
        if self.version_exists(version_id, "custom"):
            raise Exception("Version already exists") # TODO: More appropriate exception
        paths_dict = self.get_paths(version_id, "custom")
        FileTools.copy(version_jar, paths_dict["jar"])
        FileTools.copy(version_json, paths_dict["json"])

        current_listing = dict()
        current_listing["type"] = "custom"
        current_listing["name"] = version_id

        self.index.append(current_listing)

        self._flush_index()
Ejemplo n.º 11
0
    def download_official(self, version_id):
        if self.version_exists(version_id, "vanilla"):
            raise Exception("Version " + version_id + " already exists") # TODO: More appropriate exception
        paths_dict = self.get_paths(version_id, "vanilla")

        FileTools.write_object(paths_dict["jar"], URL(["versions", version_id, version_id + ".jar"], URL.DOWNLOAD).url_object())
        FileTools.write_object(paths_dict["json"], URL(["versions", version_id, version_id + ".json"], URL.DOWNLOAD).url_object())

        current_listing = dict()
        current_listing["type"] = "vanilla"
        current_listing["name"] = version_id

        self.index.append(current_listing)

        self._flush_index()
Ejemplo n.º 12
0
 def _remove_unused_objects(self, asset_id_list):
     '''
     Removes assets from the 'objects' folder that are not present in the indexes 'asset_id_list'
     This does not include virtual assets
     '''
     used_hash_list = list()
     for asset_id in asset_id_list:
         current_assets = FileTools.read_json(str(self.get_paths(asset_id)["index"]))["objects"]
         for resource in current_assets.keys():
             current_hash = current_assets[resource]["hash"]
             if not current_hash in used_hash_list:
                 used_hash_list.append(current_hash)
     for prefix_hash_dir in self.BASE_PATH.joinpath("objects").iterdir():
         for hash_file in prefix_hash_dir.iterdir():
             if not hash_file.name in used_hash_list:
                 FileTools.delete_and_clean(str(hash_file))
Ejemplo n.º 13
0
    def __init__(self, launcher_obj):
        self.Launcher = launcher_obj
        self.download_exclusive = True
        self.BASE_PATH = self.Launcher.ROOT_PATH.joinpath("lib")

        self.index_path = str(self.BASE_PATH.joinpath("index.json"))
        self.index = FileTools.read_json(self.index_path)
Ejemplo n.º 14
0
    def __init__(self, launcher_obj, name, profile_path):
        self.Launcher = launcher_obj

        self.profile_name = name
        self.data_path = profile_path
        self.metadata = FileTools.read_json(str(self.data_path.joinpath("yamcl_metadata.json")))
        self.game_process = None
Ejemplo n.º 15
0
 def _add_native_path(self):
     new_directory = self._get_filebrowser_dir_path("YAMCL: Select Natives Directory")
     if self._native_exists(new_directory):
         QtGui.QMessageBox.critical(self, "YAMCL: Native Path Exists", "Natives directory '" + new_directory + "' is already added.", QtGui.QMessageBox.Ok)
     else:
         self.last_filebrowser_dir = FileTools.dir_name(new_directory)
         self.natives_dir_list.model().appendRow(QtGui.QStandardItem(new_directory))
Ejemplo n.º 16
0
 def _get_filebrowser_file_path(self, dialog_title, file_filter=None):
     all_filters = "All Files(*)"
     if not file_filter == None:
         all_filters = file_filter + ";;" + all_filters
     file_name, current_filter = QtGui.QFileDialog.getOpenFileName(self, dialog_title, dir=self.last_filebrowser_dir, filter=all_filters)
     if file_name:
         self.last_filebrowser_dir = FileTools.dir_name(file_name)
         return file_name
     else:
         return None
Ejemplo n.º 17
0
    def delete(self, asset_id):
        '''
        Deletes assets 'asset_id'
        '''
        asset_paths = self.get_paths(asset_id)

        if self._is_virtual(FileTools.read_json(str(asset_paths["index"]))):
            FileTools.delete_and_clean(str(asset_paths["directory"]))
            FileTools.delete_and_clean(str(asset_paths["index"]))
        else:
            FileTools.delete_and_clean(str(asset_paths["index"]))
            self._remove_unused_objects(self._get_indexes())
Ejemplo n.º 18
0
    def get_paths(self, asset_id):
        '''
        Returns a dictionary containing the path to the index and directory for assets ID 'asset_id'
        '''
        asset_index_path = self.BASE_PATH.joinpath("indexes/" + asset_id + ".json")
        if not asset_index_path.exists():
            raise Exception("Assets ID " + asset_id + " does not exist")

        asset_paths = dict()
        asset_paths["index"] = asset_index_path
        if self._is_virtual(FileTools.read_json(str(asset_index_path))):
            asset_paths["directory"] = str(self.BASE_PATH.joinpath("virtual/" + asset_id))
            return asset_paths
        asset_paths["directory"] = self.BASE_PATH.joinpath("objects")
        return asset_paths
Ejemplo n.º 19
0
 def add_local(self, library_id, is_natives, source_paths, destination_path):
     '''
     source_paths is a list
     if regular library, then it should contain one string to a jar
     if natives, then it should contain paths to all natives directories
     Destination path is a path to a jar or directory (for regular or natives, respectively)
     '''
     if library_id in self.index:
         raise Exception("Library already exists") # TODO: More appropriate exception
     if isinstance(destination_path, list):
         final_path = self.BASE_PATH.joinpath(*destination_path)
     else:
         final_path = pathlib.Path(destination_path) # Assuming absolute
     if is_natives:
         for current_source in source_paths:
             try:
                 FileTools.copy(current_source, str(final_path.joinpath(FileTools.get_file_name(current_source))))
             except FileExistsError:
                 pass
     else:
         FileTools.copy(source_paths[0], str(final_path))
     self.index[library_id] = dict()
     self.index[library_id]["path"] = list(final_path.relative_to(self.BASE_PATH).parts)
     self._flush_index()
Ejemplo n.º 20
0
 def _download_library(self, library_metadata):
     if self.download_exclusive and not library_metadata.current_system_supported():
         return
     if library_metadata.is_natives():
         if self.download_exclusive:
             all_extensions = [library_metadata.get_current_system_natives_extension()]
         else:
             all_extensions = library_metadata.get_all_natives_extensions()
         natives_list = all_extensions
     if self.is_library_existant(library_metadata):
         if library_metadata.is_natives():
             natives_list = list()
             for current_extension in all_extensions:
                 if not self.is_natives_existant(library_metadata, current_extension):
                     natives_list.append(current_extension)
             if natives_list == list():
                 return # Natives already exists
         else:
             return # Library already exists
     if library_metadata.is_natives():
         download_list = library_metadata.get_download_list(natives_list)
     else:
         download_list = library_metadata.get_download_list()
     for current_library in download_list:
         current_tries = 1
         while current_tries <= 3:
             correct_hash = current_library["hash"].url_object().read().decode("UTF-8")
             FileTools.write_object(str(self.BASE_PATH.joinpath(current_library["path"])), current_library["url"].url_object())
             hasher = hashlib.sha1()
             hasher.update(open(str(self.BASE_PATH.joinpath(current_library["path"])), mode="rb").read())
             if hasher.hexdigest() == correct_hash:
                 if library_metadata.is_natives():
                     natives_directory = self.BASE_PATH.joinpath(current_library["path"].parent.joinpath(current_library["natives_extension"]))
                     jar_path = str(self.BASE_PATH.joinpath(current_library["path"]))
                     FileTools.extract_jar_files(FileTools.get_jar_object(jar_path), str(natives_directory), library_metadata.get_natives_exclude())
                     FileTools.delete_and_clean(jar_path)
                 break
             else:
                 current_tries += 1
         if current_tries == 3:
             raise Exception("Failed to download library " + library_metadata.get_id()) # TODO: More appropriate exception
     self.index[library_metadata.get_id()] = dict()
     if library_metadata.is_natives():
         self.index[library_metadata.get_id()]["path"] = download_list[0]["path"].parent.parts
     else:
         self.index[library_metadata.get_id()]["path"] = download_list[0]["path"].parts
Ejemplo n.º 21
0
 def rename(self, current_version_id, new_version_id):
     if not self.version_exists(current_version_id, "custom"):
         raise Exception("Cannot rename: " + current_version_id + " does not exist")
     if self.version_exists(new_version_id, "custom"):
         raise Exception("Cannot rename: " + new_version_id + " already exists")
     old_id_paths = self.get_paths(current_version_id, "custom")
     new_id_paths = self.get_paths(new_version_id, "custom")
     FileTools.add_missing_dirs(new_id_paths["jar"])
     for file_type in ["jar", "json"]:
         FileTools.move(old_id_paths[file_type], new_id_paths[file_type])
     FileTools.delete_and_clean(str(old_id_paths["directory"]))
     index_listing = self.index[self._get_version_index(current_version_id, "custom")]
     index_listing["name"] = new_version_id
     self._flush_index()
Ejemplo n.º 22
0
 def flush_metadata(self):
     '''
     Writes current library index in memory to the YAMCL data directory
     '''
     FileTools.write_json(str(self.data_path.joinpath("yamcl_metadata.json")), self.metadata)
Ejemplo n.º 23
0
    def __init__(self, launcher_obj):
        self.Launcher = launcher_obj
        self.BASE_PATH = self.Launcher.ROOT_PATH.joinpath("profile")

        self.index = FileTools.read_json(str(self.BASE_PATH.joinpath("index.json")))
        self.profile_instances = dict()
Ejemplo n.º 24
0
 def _flush_index(self):
     '''
     Writes current profile index in memory to the YAMCL data directory
     '''
     FileTools.write_json(str(self.BASE_PATH.joinpath("index.json")), self.index)
Ejemplo n.º 25
0
 def delete(self, library_id):
     if not library_id in self.index:
         raise Exception("Library is not existant") # TODO: More appropriate exception
     FileTools.delete_and_clean(str(self.BASE_PATH.joinpath(self.get_library_path(library_id))))
     del self.index[library_id]
     self._flush_index()
Ejemplo n.º 26
0
 def _flush_index(self):
     FileTools.write_json(self.index_path, self.index)
Ejemplo n.º 27
0
    def __init__(self, launcher_obj):
        self.Launcher = launcher_obj
        self.BASE_PATH = self.Launcher.ROOT_PATH.joinpath("bin")

        self.index_path = str(self.BASE_PATH.joinpath("index.json"))
        self.index = FileTools.read_json(self.index_path)
Ejemplo n.º 28
0
 def flush_info(self):
     FileTools.write_json(self.info_path, self.json_info)
Ejemplo n.º 29
0
    def __init__(self, launcher_obj, json_path, custom_bool):
        self.Launcher = launcher_obj
        self.is_custom = custom_bool

        self.info_path = json_path
        self.json_info = FileTools.read_json(json_path)