orrisroot
36cad6db52
To improve the tool's portability as a Python library, the core logic has been decoupled from the CLI interface. This allows developers to programmatically interact with MDRS without relying on CLI-specific argument parsing or local file-based caches. - Introduce `MdrsClient` service layer to handle core operations. - Abstract authentication state using `CacheInterface` and `InMemoryCache`. - Migrate all CLI commands to utilize `MdrsClient` for execution. - Separate `Doi` data model from API responses and move to `models/doi.py`. - Update `README.md` to include Python API usage examples. - Bump package version to 1.3.17.
267 lines
13 KiB
Python
267 lines
13 KiB
Python
import os
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
from typing import Any
|
|
from unicodedata import normalize
|
|
|
|
from mdrsclient.api import DoiApi, FilesApi, FoldersApi, LaboratoriesApi, UsersApi
|
|
from mdrsclient.commands.base import BaseCommand
|
|
from mdrsclient.connection import MDRSConnection
|
|
from mdrsclient.exceptions import IllegalArgumentException, MDRSException, UnauthorizedException, UnexpectedException
|
|
from mdrsclient.models import File, Folder, Laboratory, Token, User
|
|
from mdrsclient.models.file import find_file
|
|
from mdrsclient.settings import CONCURRENT
|
|
|
|
|
|
class MdrsClient:
|
|
"""Service layer client for MDRS."""
|
|
|
|
def __init__(self, connection: MDRSConnection):
|
|
self.connection = connection
|
|
|
|
@classmethod
|
|
def from_remote(cls, remote: str) -> "MdrsClient":
|
|
return cls(BaseCommand._create_connection(remote))
|
|
|
|
def login(self, username: str, password: str) -> tuple[Token, User]:
|
|
user_api = UsersApi(self.connection)
|
|
token = user_api.token(username, password)
|
|
self.connection.token = token
|
|
user = user_api.current()
|
|
self.connection.user = user
|
|
return token, user
|
|
|
|
def logout(self) -> None:
|
|
self.connection.logout()
|
|
|
|
def whoami(self) -> User:
|
|
user_api = UsersApi(self.connection)
|
|
return user_api.current()
|
|
|
|
def get_laboratories(self) -> list[Laboratory]:
|
|
laboratory_api = LaboratoriesApi(self.connection)
|
|
labs = laboratory_api.list()
|
|
self.connection.laboratories = labs
|
|
return list(labs)
|
|
|
|
def mkdir(self, remote_path: str) -> None:
|
|
remote, laboratory_name, r_path = BaseCommand._parse_remote_host_with_path(remote_path)
|
|
r_path = r_path.rstrip("/")
|
|
r_dirname = os.path.dirname(r_path)
|
|
r_basename = os.path.basename(r_path)
|
|
laboratory = BaseCommand._find_laboratory(self.connection, laboratory_name)
|
|
parent_folder = BaseCommand._find_folder(self.connection, laboratory, r_dirname)
|
|
files = BaseCommand._find_files(self.connection, parent_folder.id)
|
|
if parent_folder.find_sub_folder(r_basename) is not None or find_file(files, r_basename) is not None:
|
|
raise IllegalArgumentException(f"Cannot create folder `{r_path}`: File exists.")
|
|
folder_api = FoldersApi(self.connection)
|
|
folder_api.create(normalize("NFC", r_basename), parent_folder.id)
|
|
|
|
def rm(self, remote_path: str, is_recursive: bool = False) -> None:
|
|
remote, laboratory_name, r_path = BaseCommand._parse_remote_host_with_path(remote_path)
|
|
r_path = r_path.rstrip("/")
|
|
r_dirname = os.path.dirname(r_path)
|
|
r_basename = os.path.basename(r_path)
|
|
laboratory = BaseCommand._find_laboratory(self.connection, laboratory_name)
|
|
parent_folder = BaseCommand._find_folder(self.connection, laboratory, r_dirname)
|
|
parent_files = BaseCommand._find_files(self.connection, parent_folder.id)
|
|
file = find_file(parent_files, r_basename)
|
|
if file is not None:
|
|
file_api = FilesApi(self.connection)
|
|
file_api.destroy(file)
|
|
else:
|
|
folder = parent_folder.find_sub_folder(r_basename)
|
|
if folder is None:
|
|
raise IllegalArgumentException(f"Cannot remove `{r_path}`: No such file or folder.")
|
|
if not is_recursive:
|
|
raise IllegalArgumentException(f"Cannot remove `{r_path}`: Is a folder.")
|
|
folder_api = FoldersApi(self.connection)
|
|
folder_api.destroy(folder.id, True)
|
|
|
|
def ls(self, remote_path: str, password: str | None = None) -> tuple[Folder, list[File]]:
|
|
folder, laboratory = BaseCommand._resolve_folder(self.connection, remote_path, password)
|
|
files = BaseCommand._find_files(self.connection, folder.id)
|
|
return folder, files
|
|
|
|
def cp(self, src_path: str, dest_path: str, is_recursive: bool = False) -> None:
|
|
s_remote, s_laboratory_name, s_path = BaseCommand._parse_remote_host_with_path(src_path)
|
|
d_remote, d_laboratory_name, d_path = BaseCommand._parse_remote_host_with_path(dest_path)
|
|
if s_remote != d_remote:
|
|
raise IllegalArgumentException("Remote host mismatched.")
|
|
if s_laboratory_name != d_laboratory_name:
|
|
raise IllegalArgumentException("Laboratory mismatched.")
|
|
s_path = s_path.rstrip("/")
|
|
s_dirname = os.path.dirname(s_path)
|
|
s_basename = os.path.basename(s_path)
|
|
if d_path.endswith("/"):
|
|
d_dirname = d_path
|
|
d_basename = s_basename
|
|
else:
|
|
d_dirname = os.path.dirname(d_path)
|
|
d_basename = os.path.basename(d_path)
|
|
laboratory = BaseCommand._find_laboratory(self.connection, s_laboratory_name)
|
|
s_parent_folder = BaseCommand._find_folder(self.connection, laboratory, s_dirname)
|
|
s_parent_files = BaseCommand._find_files(self.connection, s_parent_folder.id)
|
|
d_parent_folder = BaseCommand._find_folder(self.connection, laboratory, d_dirname)
|
|
d_parent_files = BaseCommand._find_files(self.connection, d_parent_folder.id)
|
|
s_file = find_file(s_parent_files, s_basename)
|
|
if s_file is not None:
|
|
d_file = find_file(d_parent_files, d_basename)
|
|
if d_file is not None:
|
|
raise IllegalArgumentException(f"File `{d_basename}` already exists.")
|
|
d_sub_folder = d_parent_folder.find_sub_folder(d_basename)
|
|
if d_sub_folder is not None:
|
|
raise IllegalArgumentException(f"Cannot overwrite non-folder `{d_basename}` with folder `{d_path}`.")
|
|
file_api = FilesApi(self.connection)
|
|
if s_parent_folder.id != d_parent_folder.id or d_basename != s_basename:
|
|
file_api.copy(s_file, d_parent_folder.id, normalize("NFC", d_basename))
|
|
else:
|
|
s_folder = s_parent_folder.find_sub_folder(s_basename)
|
|
if s_folder is None:
|
|
raise IllegalArgumentException(f"File or folder `{s_basename}` not found.")
|
|
if not is_recursive:
|
|
raise IllegalArgumentException(f"Cannot copy `{s_path}`: Is a folder.")
|
|
if find_file(d_parent_files, d_basename) is not None:
|
|
raise IllegalArgumentException(f"Cannot overwrite non-folder `{d_basename}` with folder `{s_path}`.")
|
|
d_folder = d_parent_folder.find_sub_folder(d_basename)
|
|
if d_folder is not None:
|
|
if d_folder.id == s_folder.id:
|
|
raise IllegalArgumentException(f"`{s_path}` and `{s_path}` are the same folder.")
|
|
raise IllegalArgumentException(f"Cannot move `{s_path}` to `{d_path}`: Folder not empty.")
|
|
folder_api = FoldersApi(self.connection)
|
|
if s_parent_folder.id != d_parent_folder.id or s_basename != d_basename:
|
|
folder_api.copy(s_folder, d_parent_folder.id, normalize("NFC", d_basename))
|
|
|
|
def mv(self, src_path: str, dest_path: str) -> None:
|
|
s_remote, s_laboratory_name, s_path = BaseCommand._parse_remote_host_with_path(src_path)
|
|
d_remote, d_laboratory_name, d_path = BaseCommand._parse_remote_host_with_path(dest_path)
|
|
if s_remote != d_remote:
|
|
raise IllegalArgumentException("Remote host mismatched.")
|
|
if s_laboratory_name != d_laboratory_name:
|
|
raise IllegalArgumentException("Laboratory mismatched.")
|
|
s_path = s_path.rstrip("/")
|
|
s_dirname = os.path.dirname(s_path)
|
|
s_basename = os.path.basename(s_path)
|
|
if d_path.endswith("/"):
|
|
d_dirname = d_path
|
|
d_basename = s_basename
|
|
else:
|
|
d_dirname = os.path.dirname(d_path)
|
|
d_basename = os.path.basename(d_path)
|
|
laboratory = BaseCommand._find_laboratory(self.connection, s_laboratory_name)
|
|
s_parent_folder = BaseCommand._find_folder(self.connection, laboratory, s_dirname)
|
|
s_parent_files = BaseCommand._find_files(self.connection, s_parent_folder.id)
|
|
d_parent_folder = BaseCommand._find_folder(self.connection, laboratory, d_dirname)
|
|
d_parent_files = BaseCommand._find_files(self.connection, d_parent_folder.id)
|
|
s_file = find_file(s_parent_files, s_basename)
|
|
if s_file is not None:
|
|
d_file = find_file(d_parent_files, d_basename)
|
|
if d_file is not None:
|
|
raise IllegalArgumentException(f"File `{d_basename}` already exists.")
|
|
d_sub_folder = d_parent_folder.find_sub_folder(d_basename)
|
|
if d_sub_folder is not None:
|
|
raise IllegalArgumentException(f"Cannot overwrite non-folder `{d_basename}` with folder `{d_path}`.")
|
|
file_api = FilesApi(self.connection)
|
|
if s_parent_folder.id != d_parent_folder.id or d_basename != s_basename:
|
|
file_api.move(s_file, d_parent_folder.id, normalize("NFC", d_basename))
|
|
else:
|
|
s_folder = s_parent_folder.find_sub_folder(s_basename)
|
|
if s_folder is None:
|
|
raise IllegalArgumentException(f"File or folder `{s_basename}` not found.")
|
|
if find_file(d_parent_files, d_basename) is not None:
|
|
raise IllegalArgumentException(f"Cannot overwrite non-folder `{d_basename}` with folder `{s_path}`.")
|
|
d_folder = d_parent_folder.find_sub_folder(d_basename)
|
|
if d_folder is not None:
|
|
if d_folder.id == s_folder.id:
|
|
raise IllegalArgumentException(f"`{s_path}` and `{s_path}` are the same folder.")
|
|
raise IllegalArgumentException(f"Cannot move `{s_path}` to `{d_path}`: Folder not empty.")
|
|
folder_api = FoldersApi(self.connection)
|
|
if s_parent_folder.id != d_parent_folder.id or d_basename != s_basename:
|
|
folder_api.move(s_folder, d_parent_folder.id, normalize("NFC", d_basename))
|
|
|
|
def chacl(
|
|
self, remote_path: str, access_level: int, is_recursive: bool = False, password: str | None = None
|
|
) -> None:
|
|
remote, laboratory_name, r_path = BaseCommand._parse_remote_host_with_path(remote_path)
|
|
r_path = r_path.rstrip("/")
|
|
laboratory = BaseCommand._find_laboratory(self.connection, laboratory_name)
|
|
folder = BaseCommand._find_folder(self.connection, laboratory, r_path)
|
|
folder_api = FoldersApi(self.connection)
|
|
folder_api.acl(folder.id, access_level, is_recursive, password)
|
|
|
|
def metadata(self, remote_path: str, password: str | None = None) -> dict:
|
|
folder, laboratory = BaseCommand._resolve_folder(self.connection, remote_path, password)
|
|
folder_api = FoldersApi(self.connection)
|
|
return folder_api.metadata(folder.id)
|
|
|
|
def file_metadata(self, remote_path: str, password: str | None = None) -> dict:
|
|
folder, laboratory, r_basename = BaseCommand._resolve_file(self.connection, remote_path, password)
|
|
files = BaseCommand._find_files(self.connection, folder.id)
|
|
file = find_file(files, r_basename)
|
|
if file is None:
|
|
raise IllegalArgumentException(f"File `{r_basename}` not found.")
|
|
file_api = FilesApi(self.connection)
|
|
return file_api.metadata(file)
|
|
|
|
def _create_connection(self, remote: str):
|
|
return self.connection
|
|
|
|
def upload(
|
|
self, local_path: str, remote_path: str, is_recursive: bool = False, is_skip_if_exists: bool = False
|
|
) -> None:
|
|
from mdrsclient.commands.upload import UploadCommand
|
|
|
|
UploadCommand._upload_logic(self.connection, local_path, remote_path, is_recursive, is_skip_if_exists)
|
|
|
|
def download(
|
|
self,
|
|
remote_path: str,
|
|
local_path: str,
|
|
is_recursive: bool = False,
|
|
is_skip_if_exists: bool = False,
|
|
password: str | None = None,
|
|
excludes: list[str] | None = None,
|
|
) -> None:
|
|
from mdrsclient.commands.download import DownloadCommand
|
|
|
|
DownloadCommand._download_logic(
|
|
self.connection, remote_path, local_path, is_recursive, is_skip_if_exists, password, excludes or []
|
|
)
|
|
|
|
def ls_command(
|
|
self,
|
|
remote_path: str,
|
|
password: str | None = None,
|
|
is_json: bool = False,
|
|
is_recursive: bool = False,
|
|
is_quiet: bool = False,
|
|
) -> None:
|
|
from mdrsclient.commands.ls import LsCommand
|
|
|
|
LsCommand._ls_logic(self.connection, remote_path, password, is_json, is_recursive, is_quiet)
|
|
|
|
def version(self) -> str:
|
|
from mdrsclient.__version__ import __version__
|
|
|
|
return f"mdrs {__version__}"
|
|
|
|
def config_create(self, remote: str, url: str) -> None:
|
|
from mdrsclient.commands.config import ConfigCommand
|
|
|
|
ConfigCommand.create(remote, url)
|
|
|
|
def config_update(self, remote: str, url: str) -> None:
|
|
from mdrsclient.commands.config import ConfigCommand
|
|
|
|
ConfigCommand.update(remote, url)
|
|
|
|
def config_list(self) -> list:
|
|
from mdrsclient.config import ConfigFile
|
|
|
|
config = ConfigFile("")
|
|
return config.list()
|
|
|
|
def config_delete(self, remote: str) -> None:
|
|
from mdrsclient.commands.config import ConfigCommand
|
|
|
|
ConfigCommand.delete(remote)
|