def check_version(self): """Check the version of the client and the server. :return: """ response = requests.get(self.client.api_url) parse_error(response, json=False) version = int(response.content.decode("utf-8").split("\n")[1]) if version != CLIENT_VERSION: raise VersionDiscrepancy( f"The Version of the server is {version} and the version of the client {CLIENT_VERSION}: Please " f"update the client or the server! ")
def get(self, group: GroupTarget, key: str = None, private_key: str = None): """Fetch a group. :param group: The target to the group. :param key: The key of the group (if you have set the key in the group target, you must not set this parameter). :param private_key: The private_key of the group (if you have set the private_key in the group target, you must not set this parameter). :return: :class:`Group`. """ key, private_key = check_group_values(group, key, private_key) path = f"{self.client.api_url}/group/{group.name}" response = requests.put(path, data={ "key": key, "private_key": private_key }) j = parse_error(response) return Group( group.name, key, j["hashed_key"], private_key, [FileTarget(key, file, group=group) for file in j["files"]], )
def delete_authentication_token(self, authentication_token): """Delete a authentication token on the server. :param authentication_token: The authentication token to authenticate. :return: """ response = requests.delete( f"{self.client.api_url}/authentication", data={"authentication_token": authentication_token}, ) j = parse_error(response) if not ("status" in j and j["status"] == "success"): raise BasicError()
def test_authentication(self, authentication_token): """Test the authentication token (Attention: don't use this function in production, because the action needs some time). :param authentication_token: The authentication token to authenticate. :return: """ response = requests.post( f"{self.client.api_url}/authentication/test", data={"authentication_token": authentication_token}, ) j = parse_error(response) if not ("status" in j and j["status"] == "success"): raise BasicError()
def get( self, key, filename, group: GroupTarget = None, read_from_cache=True, write_in_cache=True, ): """Download/Get any content of the file. :param key: The file is encrypted with this key. :param filename: The name of the file. :param group: If you would like to download a file which belongs to any group, you must hand over the group target. :param read_from_cache: If the file is cached, the function would return the cached file. :param write_in_cache: If the file has been successfully loaded, the file would be cached. :return: :class:`File` """ if read_from_cache and group is None: for file in self.cached_files: if file.key == key and file.filename == filename: return file if group is None: response = requests.get(f"{self.client.api_url}/{key}/{filename}") parse_error(response, check_json=True) file = File(key, None, filename, None, response.content) if write_in_cache: self.cached_files.append(file) return file else: key = check_group_values(group, key) response = requests.get( f"{self.client.api_url}/{group.name}/{key}/{filename}") parse_error(response, check_json=True) return File(key, None, filename, None, response.content, group=group)
def create_authentication_token(self, key_identifier, private_key: RSA.RsaKey): """Create new authentication token :param key_identifier: The identifier of the key (the variable key on the server). :param private_key: The :class:`RSA.RsaKey` Key for authentication. :return: string authentication_token """ response = requests.post( f"{self.client.api_url}/authentication", data={"key_identifier": key_identifier}, ) j = parse_error(response) encrypted_authentication_token = j["encrypted_authentication_token"] return ( PKCS1_OAEP.new(private_key) .decrypt(base64.b64decode(encrypted_authentication_token.encode("utf-8"))) .decode("utf-8") )
def delete(self, group: GroupTarget, private_key: str = None): """Delete a group and all files in the group. :param group: The target to the group. :param private_key: The private_key of the group (if you have set the private_key in the group target, you must not set this parameter). :return: """ if group.private_key is None and private_key is None: raise ValueError( "The GroupTarget does not provide any private_key, so you put the private_key in the function!" ) if private_key is None: private_key = group.private_key path = f"{self.client.api_url}/group/{group.name}" response = requests.delete(path, data={"private_key": private_key}) j = parse_error(response) if "status" not in j or j["status"] != "success": raise BasicError()
def delete(self, file: FileTarget, key=None, private_key=None): """Delete a file. :param file: The target of the deleting file. :param private_key: If the target isn't loaded, you should set a private_key yourself. Group File Deletion ========== If the file belongs to any group (the file.group is not None), the function will delete the group file automatically. If you don't hand over the key or private_key in the group target you need following parameters: :param key: The key of the group. :param private_key: The private_key of the group. """ if ((not file.loaded and private_key is None) or (private_key is None and file.file.private_key is None)) and ( file.group is None or file.group.private_key is None): raise ValueError( "The file is not loaded and no private_key was set or the file doesn't have any private_key" ) if private_key is None: private_key = file.file.private_key if private_key is None: private_key = file.group.private_key if file.group is None: response = requests.delete( f"{self.client.api_url}/{file.key}/{file.filename}", data={"private_key": private_key}, ) else: key = check_group_values(file.group, key) response = requests.delete( f"{self.client.api_url}/{file.group.name}/{key}/{file.filename}", data={"private_key": private_key}, ) j = parse_error(response) if not ("status" in j and j["status"] == "success"): raise BasicError() for f in self.cached_files: if f.key == file.key and f.filename == file.filename: self.cached_files.remove(f)
def post(self, group_name: str, private_key: str = None, authentication_token: str = None) -> Group: """Create a new group. :param group_name: The name of the new group. :param private_key: You can set a private_key. If you don't set any private_key the server will generate a random private_key. :param authentication_token: If upload_authentication is required, you must set the authentication_token. :return: The new :class:`Group`. """ path = f"{self.client.api_url}/group/{group_name}" response = requests.post( path, data={ "authentication_token": authentication_token, "private_key": private_key, }, ) j = parse_error(response) return Group(j["name"], j["key"], j["hashed_key"], j["private_key"], [])
def post( self, raw_file, filename, group: GroupTarget = None, key: str = None, private_key: str = None, authentication_token=None, ): """Create/Upload a file. :param raw_file: The file (open it with open()). :param filename: The name of the file. :param authentication_token: If the server requires authentication for posting data, you should set the authentication_token. Group Upload ========== :param group: The target to the group of the file. :param key: The key of the group ( you don't need the key, if you have hand over the key in the group target). :param private_key: The private_key of the group (you don't need the private_key, if you have hand over the private_key in the group target). :return: :class:`File` Usage:: filename = 'test.test' file = file_manager.post(open(filename, 'r'), filename) """ if group is None: response = requests.post( f"{self.client.api_url}/upload", files={"file": (filename, raw_file)}, data={ "authentication_token": authentication_token, "private_key": private_key, }, ) j = parse_error(response) file = File(j["key"], j["hashed_key"], j["filename"], j["private_key"], None) else: key, private_key = check_group_values(group, key, private_key) response = requests.post( f"{self.client.api_url}/upload", files={"file": (filename, raw_file)}, data={ "authentication_token": authentication_token, "group": group.name, "key": key, "private_key": private_key, }, ) j = parse_error(response) file = File( j["key"], j["hashed_key"], j["filename"], j["private_key"], None, group=group, ) return file