sapiopycommons 2024.8.27a312__py3-none-any.whl → 2024.8.28a313__py3-none-any.whl

sapiopycommons/eln/experiment_report_util.py

@@ -1,214 +0,0 @@
-from sapiopylib.rest.User import SapioUser
-from sapiopylib.rest.pojo.CustomReport import (
-    CompositeReportTerm,
-    CompositeTermOperation,
-    CustomReportCriteria,
-    ExplicitJoinDefinition,
-    FieldCompareReportTerm,
-    RawReportTerm,
-    RawTermOperation,
-    ReportColumn,
-)
-from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
-from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
-from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
-
-from sapiopycommons.general.aliases import SapioRecord
-from sapiopycommons.general.custom_report_util import CustomReportUtil
-from sapiopycommons.recordmodel.record_handler import RecordHandler
-
-_NOTEBOOK_ID = "EXPERIMENTID"
-_RECORD_ID = "RECORDID"
-
-
-# FR-46908 - Provide a utility class that holds experiment related custom reports e.g. getting all the experiments
-# that given records were used in or getting all records of a datatype used in given experiments.
-class ExperimentReportUtil:
-    @staticmethod
-    def map_records_to_experiment_ids(
-        context: SapioWebhookContext | SapioUser,
-        records: list[SapioRecord],
-    ) -> dict[SapioRecord, list[int]]:
-        """
-        Return a dictionary mapping each record to a list of ids of experiments that they were used in.
-        If a record wasn't used in any experiments then it will be mapped to an empty list.
-
-        :param context: The current webhook context or a user object to send requests from.
-        :param records: a list of records of the same data type.
-        :return: a dictionary mapping each record to a list of ids of each experiment it was used in.
-        """
-        if not records:
-            return {}
-
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
-
-        data_type_name = records[0].data_type_name
-
-        record_ids = [record.record_id for record in records]
-
-        rows = ExperimentReportUtil.__get_record_experiment_relation_rows(
-            user, data_type_name, record_ids=record_ids
-        )
-
-        id_to_record: dict[int, SapioRecord] = RecordHandler.map_by_id(records)
-
-        record_to_exps: dict[SapioRecord, set[int]] = {
-            record: set() for record in records
-        }
-
-        for row in rows:
-            record_id: int = row[_RECORD_ID]
-            exp_id: int = row[_NOTEBOOK_ID]
-
-            record = id_to_record[record_id]
-
-            record_to_exps[record].add(exp_id)
-
-        return {record: list(exps) for record, exps in record_to_exps.items()}
-
-    @staticmethod
-    def map_experiments_to_records_of_type(
-        context: SapioWebhookContext | SapioUser,
-        exp_ids: list[int],
-        wrapper_type: type[WrappedType],
-    ) -> dict[int, list[WrappedType]]:
-        """
-        Return a dictionary mapping each experiment id to a list of records of the given type that were used in each experiment.
-        If an experiment didn't use any records of the given type then it will be mapped to an empty list.
-
-        :param context: The current webhook context or a user object to send requests from.
-        :param exp_ids: a list of experiment ids. These are specifically the Notebook Experiment ids which can be found in the title of the experiment.
-        :param wrapper_type: The record model wrapper to use, corresponds to which data type we will query for.
-        :return: a dictionary mapping each experiment id to a list of records of the given type that were used in that experiment.
-        """
-        if not exp_ids:
-            return {}
-
-        user = context if isinstance(context, SapioUser) else context.user
-
-        record_handler = RecordHandler(user)
-
-        data_type_name: str = wrapper_type.get_wrapper_data_type_name()
-
-        rows = ExperimentReportUtil.__get_record_experiment_relation_rows(
-            user, data_type_name, exp_ids=exp_ids
-        )
-
-        record_ids: set[int] = {row[_RECORD_ID] for row in rows}
-
-        records = record_handler.query_models_by_id(wrapper_type, record_ids)
-
-        id_to_record: dict[int, WrappedType] = RecordHandler.map_by_id(records)
-
-        exp_to_records: dict[int, set[SapioRecord]] = {exp: set() for exp in exp_ids}
-
-        for row in rows:
-            record_id: int = row[_RECORD_ID]
-            exp_id: int = row[_NOTEBOOK_ID]
-
-            record = id_to_record[record_id]
-
-            exp_to_records[exp_id].add(record)
-
-        return {exp: list(records) for exp, records in exp_to_records.items()}
-
-    @staticmethod
-    def __get_record_experiment_relation_rows(
-        user: SapioUser,
-        data_type_name: str,
-        record_ids: list[int] | None = None,
-        exp_ids: list[int] | None = None,
-    ) -> list[dict[str, int]]:
-        """
-        Return a list of dicts mapping \"RECORDID\" to the record id and \"EXPERIMENTID\" to the experiment id.
-        At least one of record_ids and exp_ids should be provided.
-        """
-        assert (record_ids or exp_ids)
-
-        if record_ids:
-            rec_ids = [str(record_id) for record_id in record_ids]
-
-            ids_str = "{" + ", ".join(rec_ids) + "}"
-
-            records_term = RawReportTerm(
-                data_type_name, "RECORDID", RawTermOperation.EQUAL_TO_OPERATOR, ids_str
-            )
-
-        else:
-            # Get all records of the given type
-            records_term = RawReportTerm(
-                data_type_name,
-                "RECORDID",
-                RawTermOperation.GREATER_THAN_OR_EQUAL_OPERATOR,
-                "0",
-            )
-
-        if exp_ids:
-            exp_ids = [str(exp_id) for exp_id in exp_ids]
-
-            ids_str = "{" + ", ".join(exp_ids) + "}"
-
-            exp_term = RawReportTerm(
-                "NOTEBOOKEXPERIMENT",
-                "EXPERIMENTID",
-                RawTermOperation.EQUAL_TO_OPERATOR,
-                ids_str,
-            )
-
-        else:
-            # Get all experiments
-            exp_term = RawReportTerm(
-                "NOTEBOOKEXPERIMENT",
-                "EXPERIMENTID",
-                RawTermOperation.GREATER_THAN_OR_EQUAL_OPERATOR,
-                "0",
-            )
-
-        root_term = CompositeReportTerm(
-            records_term, CompositeTermOperation.AND_OPERATOR, exp_term
-        )
-
-        # The columns the resulting dataframe will have
-        column_list = [
-            ReportColumn(data_type_name, "RECORDID", FieldType.LONG),
-            ReportColumn("NOTEBOOKEXPERIMENT", "EXPERIMENTID", FieldType.LONG),
-        ]
-
-        # Join records on the experiment entry records that correspond to them.
-        records_entry_join = FieldCompareReportTerm(
-            data_type_name,
-            "RECORDID",
-            RawTermOperation.EQUAL_TO_OPERATOR,
-            "EXPERIMENTENTRYRECORD",
-            "RECORDID",
-        )
-
-        # Join entry records on the experiment entries they are in.
-        experiment_entry_enb_entry_join = FieldCompareReportTerm(
-            "EXPERIMENTENTRYRECORD",
-            "ENTRYID",
-            RawTermOperation.EQUAL_TO_OPERATOR,
-            "ENBENTRY",
-            "ENTRYID",
-        )
-
-        # Join entries on the experiments they are in.
-        enb_entry_experiment_join = FieldCompareReportTerm(
-            "ENBENTRY",
-            "EXPERIMENTID",
-            RawTermOperation.EQUAL_TO_OPERATOR,
-            "NOTEBOOKEXPERIMENT",
-            "EXPERIMENTID",
-        )
-
-        report_criteria = CustomReportCriteria(
-            column_list,
-            root_term,
-            join_list=[
-                ExplicitJoinDefinition("EXPERIMENTENTRYRECORD", records_entry_join),
-                ExplicitJoinDefinition("ENBENTRY", experiment_entry_enb_entry_join),
-                ExplicitJoinDefinition("NOTEBOOKEXPERIMENT", enb_entry_experiment_join),
-            ],
-        )
-
-        return CustomReportUtil.run_custom_report(user, report_criteria)

sapiopycommons/files/file_bridge_handler.py

@@ -1,318 +0,0 @@
-from __future__ import annotations
-
-from abc import abstractmethod, ABC
-
-from sapiopycommons.files.file_bridge import FileBridge
-from sapiopylib.rest.User import SapioUser
-from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
-
-
-class FileBridgeHandler:
-    """
-    The FileBridgeHandler provides caching of the results of file bridge endpoint calls while also containing quality
-    of life functions for common file bridge actions.
-    """
-    user: SapioUser
-    __bridge: str
-    __file_cache: dict[str, bytes]
-    """A cache of file paths to file bytes."""
-    __files: dict[str, File]
-    """A cache of file paths to File objects."""
-    __dir_cache: dict[str, list[str]]
-    """A cache of directory file paths to the names of the files or nested directories within it."""
-    __directories: dict[str, Directory]
-    """A cache of directory file paths to Directory objects."""
-
-    def __init__(self, context: SapioWebhookContext | SapioUser, bridge_name: str):
-        """
-        :param context: The current webhook context or a user object to send requests from.
-        :param bridge_name: The name of the bridge to communicate with. This is the "connection name" in the
-            file bridge configurations.
-        """
-        self.user = context if isinstance(context, SapioUser) else context.user
-        self.__bridge = bridge_name
-        self.__file_cache = {}
-        self.__files = {}
-        self.__dir_cache = {}
-        self.__directories = {}
-
-    @property
-    def connection_name(self) -> str:
-        return self.__bridge
-
-    def clear_caches(self) -> None:
-        """
-        Clear the file and directory caches of this handler.
-        """
-        self.__file_cache.clear()
-        self.__files.clear()
-        self.__dir_cache.clear()
-        self.__directories.clear()
-
-    def read_file(self, file_path: str, base64_decode: bool = True) -> bytes:
-        """
-        Read a file from FileBridge. The bytes of the given file will be cached so that any subsequent reads of this
-        file will not make an additional webservice call.
-
-        :param file_path: The path to read the file from.
-        :param base64_decode: If true, base64 decode the file. Files are by default base64 encoded when retrieved from
-            FileBridge.
-        :return: The bytes of the file.
-        """
-        if file_path in self.__file_cache:
-            return self.__file_cache[file_path]
-        file_bytes: bytes = FileBridge.read_file(self.user, self.__bridge, file_path, base64_decode)
-        self.__file_cache[file_path] = file_bytes
-        return file_bytes
-
-    def write_file(self, file_path: str, file_data: bytes | str) -> None:
-        """
-        Write a file to FileBridge. The bytes of the given file will be cached so that any subsequent reads of this
-        file will not make an additional webservice call.
-
-        :param file_path: The path to write the file to. If a file already exists at the given path then the file is
-            overwritten.
-        :param file_data: A string or bytes of the file to be written.
-        """
-        FileBridge.write_file(self.user, self.__bridge, file_path, file_data)
-        self.__file_cache[file_path] = file_data if isinstance(file_data, bytes) else file_data.encode()
-
-        # Find the directory path to this file and the name of the file. Add the file name to the cached list of
-        # files for the directory, assuming we have this directory cached and the file isn't already in it.
-        last_slash: int = file_path.rfind("/")
-        dir_path: str = file_path[:last_slash]
-        file_name: str = file_path[last_slash + 1:]
-        if dir_path in self.__dir_cache and file_path not in self.__dir_cache[dir_path]:
-            self.__dir_cache[dir_path].append(file_name)
-
-    def delete_file(self, file_path: str) -> None:
-        """
-        Delete an existing file in FileBridge. If this file is in the cache, it will also be deleted from the cache.
-
-        :param file_path: The path to the file to delete.
-        """
-        FileBridge.delete_file(self.user, self.__bridge, file_path)
-        if file_path in self.__file_cache:
-            self.__file_cache.pop(file_path)
-        if file_path in self.__files:
-            self.__files.pop(file_path)
-
-    def list_directory(self, file_path: str) -> list[str]:
-        """
-        List the contents of a FileBridge directory. The contents of this directory will be cached so that any
-        subsequent lists of this directory will not make an additional webservice call.
-
-        :param file_path: The path to read the directory from.
-        :return: A list of names of files and folders in the directory.
-        """
-        if file_path in self.__dir_cache:
-            return self.__dir_cache[file_path]
-        files: list[str] = FileBridge.list_directory(self.user, self.__bridge, file_path)
-        self.__dir_cache[file_path] = files
-        return files
-
-    def create_directory(self, file_path: str) -> None:
-        """
-        Create a new directory in FileBridge. This new directory will be added to the cache as empty so that listing
-        the same directory does not make an additional webservice call.
-
-        :param file_path: The path to create the directory at. If a directory already exists at the given path then an
-            exception is raised.
-        """
-        FileBridge.create_directory(self.user, self.__bridge, file_path)
-        # This directory was just created, so we know it's empty.
-        self.__dir_cache[file_path] = []
-
-    def delete_directory(self, file_path: str) -> None:
-        """
-        Delete an existing directory in FileBridge. If this directory is in the cache, it will also be deleted
-        from the cache.
-
-        :param file_path: The path to the directory to delete.
-        """
-        FileBridge.delete_directory(self.user, self.__bridge, file_path)
-        if file_path in self.__dir_cache:
-            self.__dir_cache.pop(file_path)
-        if file_path in self.__directories:
-            self.__directories.pop(file_path)
-
-    def is_file(self, file_path: str) -> bool:
-        """
-        Determine if the given file path points to a file or a directory. This is achieved by trying to call
-        list_directory on the given file path. If an exception is thrown, that's because the function was called
-        on a file. If no exception is thrown, then we know that this is a directory, and we have now also cached
-        the contents of that directory if it wasn't cached already.
-
-        :param file_path: A file path.
-        :return: True if the file path points to a file. False if it points to a directory.
-        """
-        try:
-            self.list_directory(file_path)
-            return False
-        except Exception:
-            return True
-
-    def move_file(self, move_from: str, move_to: str, old_name: str, new_name: str | None = None) -> None:
-        """
-        Move a file from one location to another within File Bridge. This is done be reading the file into memory,
-        writing a copy of the file in the new location, then deleting the original file.
-
-        :param move_from: The path to the current location of the file.
-        :param move_to: The path to move the file to.
-        :param old_name: The current name of the file.
-        :param new_name: The name that the file should have after it is moved. if this is not provided, then the new
-            name will be the same as the old name.
-        """
-        if not new_name:
-            new_name = old_name
-
-        # Read the file into memory.
-        file_bytes: bytes = self.read_file(move_from + "/" + old_name)
-        # Write the file into the new location.
-        self.write_file(move_to + "/" + new_name, file_bytes)
-        # Delete the file from the old location. We do this last in case the write call fails.
-        self.delete_file(move_from + "/" + old_name)
-
-    def get_file_object(self, file_path: str) -> File:
-        """
-        Get a File object from a file path. This object can be used to get the contents of the file at this path
-        and traverse up the file hierarchy to the directory that the file is contained within.
-
-        There is no guarantee that this file actually exists within the current file bridge connection when it is
-        constructed. If the file doesn't exist, then retrieving its contents will fail.
-
-        :param file_path: A file path.
-        :return: A File object constructed form the given file path.
-        """
-        if file_path in self.__files:
-            return self.__files[file_path]
-        file = File(self, file_path)
-        self.__files[file_path] = file
-        return file
-
-    def get_directory_object(self, file_path: str) -> Directory | None:
-        """
-        Get a Directory object from a file path. This object can be used to traverse up and down the file hierarchy
-        by going up to the parent directory that this directory is contained within or going down to the contents of
-        this directory.
-
-        There is no guarantee that this directory actually exists within the current file bridge connection when it is
-        constructed. If the directory doesn't exist, then retrieving its contents will fail.
-
-        :param file_path: A file path.
-        :return: A Directory object constructed form the given file path.
-        """
-        if file_path is None:
-            return None
-        if file_path in self.__directories:
-            return self.__directories[file_path]
-        directory = Directory(self, file_path)
-        self.__directories[file_path] = directory
-        return directory
-
-
-class FileBridgeObject(ABC):
-    """
-    A FileBridgeObject is either a file or a directory that is contained within file bridge. Every object has a
-    name and a parent directory that it is contained within (unless the object is located in the bridge root, in
-    which case the parent is None). From the name and the parent, a path can be constructed to that object.
-    """
-    _handler: FileBridgeHandler
-    name: str
-    parent: Directory | None
-
-    def __init__(self, handler: FileBridgeHandler, file_path: str):
-        self._handler = handler
-
-        name, root = split_path(file_path)
-        self.name = name
-        self.parent = handler.get_directory_object(root)
-
-    @abstractmethod
-    def is_file(self) -> bool:
-        """
-        :return: True if this object is a file. False if it is a directory.
-        """
-        pass
-
-    def get_path(self) -> str:
-        """
-        :return: The file path that leads to this object.
-        """
-        if self.parent is None:
-            return self.name
-        return self.parent.get_path() + "/" + self.name
-
-
-class File(FileBridgeObject):
-    def __init__(self, handler: FileBridgeHandler, file_path: str):
-        """
-        :param handler: A FileBridgeHandler for the connection that this file came from.
-        :param file_path: The path to this file.
-        """
-        super().__init__(handler, file_path)
-
-    @property
-    def contents(self) -> bytes:
-        """
-        :return: The bytes of this file.
-            This pulls from the cache of this object's related FileBridgeHandler.
-        """
-        return self._handler.read_file(self.get_path())
-
-    def is_file(self) -> bool:
-        return True
-
-
-class Directory(FileBridgeObject):
-    def __init__(self, handler: FileBridgeHandler, file_path: str):
-        """
-        :param handler: A FileBridgeHandler for the connection that this directory came from.
-        :param file_path: The path to this directory.
-        """
-        super().__init__(handler, file_path)
-
-    @property
-    def contents(self) -> dict[str, FileBridgeObject]:
-        """
-        :return: A dictionary of object names to the objects (Files or Directories) contained within this Directory.
-            This pulls from the cache of this object's related FileBridgeHandler.
-        """
-        contents: dict[str, FileBridgeObject] = {}
-        path: str = self.get_path()
-        for name in self._handler.list_directory(path):
-            file_path: str = path + "/" + name
-            if self._handler.is_file(file_path):
-                contents[name] = self._handler.get_file_object(file_path)
-            else:
-                contents[name] = self._handler.get_directory_object(file_path)
-        return contents
-
-    def is_file(self) -> bool:
-        return False
-
-    def get_files(self) -> dict[str, File]:
-        """
-        :return: A mapping of file name to File for every file in this Directory.
-            This pulls from the cache of this object's related FileBridgeHandler.
-        """
-        return {x: y for x, y in self.contents.items() if y.is_file()}
-
-    def get_directories(self) -> dict[str, Directory]:
-        """
-        :return: A mapping of directory name to Directory for every directory in this Directory.
-            This pulls from the cache of this object's related FileBridgeHandler.
-        """
-        return {x: y for x, y in self.contents.items() if not y.is_file()}
-
-
-def split_path(file_path: str) -> (str, str):
-    """
-    :param file_path: A file path where directories are separated the "/" characters.
-    :return: A tuple of two strings that splits the path on its last slash. The first string is the name of the
-        file/directory at the given file path and the second string is the location to that file.
-    """
-    last_slash: int = file_path.rfind("/")
-    if last_slash == -1:
-        return file_path, None
-    return file_path[last_slash + 1:], file_path[:last_slash]