sapiopycommons 2024.3.19a157__py3-none-any.whl → 2025.1.17a402__py3-none-any.whl

sapiopycommons/rules/eln_rule_handler.py

@@ -1,8 +1,15 @@
+from __future__ import annotations
+
+from weakref import WeakValueDictionary
+
+from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.DataRecord import DataRecord
+from sapiopylib.rest.pojo.eln.SapioELNEnums import ElnBaseDataType
 from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelManager, RecordModelInstanceManager
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 
+from sapiopycommons.general.aliases import FieldMap, AliasUtil, DataTypeIdentifier
 from sapiopycommons.general.exceptions import SapioException
 
 
@@ -10,7 +17,6 @@ from sapiopycommons.general.exceptions import SapioException
 class ElnRuleHandler:
     """
     A class which helps with the parsing and navigation of the ELN rule result map of a webhook context.
-    TODO: Add functionality around the VeloxRuleType of the rule results.
     """
     __context: SapioWebhookContext
     """The context that this handler is working from."""
@@ -24,8 +30,33 @@ class ElnRuleHandler:
     __entry_to_records: dict[str, dict[str, set[DataRecord]]]
     """A mapping of entry name to the sets of data records for that entry, each set of records being mapped by its
     data type."""
+    __field_maps: dict[str, dict[int, FieldMap]]
+    """A mapping of data type to the field maps from the context that match that data type. In order to prevent
+    duplicate field maps, each field map is in a dict keyed by the RecordId field in the field map, since field maps
+    are just dictionaries and dictionaries aren't hashable and therefore can't go in a set."""
+    __entry_to_field_maps: dict[str, dict[str, dict[int, FieldMap]]]
+    """A mapping of entry name to the lists of field maps for that entry, each grouping of field maps being mapped by
+    its data type."""
+
+    __instances: WeakValueDictionary[SapioUser, ElnRuleHandler] = WeakValueDictionary()
+    __initialized: bool
+
+    def __new__(cls, context: SapioWebhookContext):
+        if context.velox_eln_rule_result_map is None:
+            raise SapioException("No Velox ELN rule result map in context for ElnRuleHandler to parse.")
+        user = context if isinstance(context, SapioUser) else context.user
+        obj = cls.__instances.get(user)
+        if not obj:
+            obj = object.__new__(cls)
+            obj.__initialized = False
+            cls.__instances[user] = obj
+        return obj
 
     def __init__(self, context: SapioWebhookContext):
+        if self.__initialized:
+            return
+        self.__initialized = True
+
         if context.velox_eln_rule_result_map is None:
             raise SapioException("No Velox ELN rule result map in context for ElnRuleHandler to parse.")
         self.__context = context
@@ -55,12 +86,8 @@ class ElnRuleHandler:
                         # Get the data type of this record. If this is an ELN type, ignore the digits.
                         data_type: str = record.data_type_name
                         # PR-46331: Ensure that all ELN types are converted to their base data type name.
-                        if data_type.startswith("ELNExperiment_"):
-                            data_type = "ELNExperiment"
-                        elif data_type.startswith("ELNExperimentDetail_"):
-                            data_type = "ELNExperimentDetail"
-                        elif data_type.startswith("ELNSampleDetail_"):
-                            data_type = "ELNSampleDetail"
+                        if ElnBaseDataType.is_eln_type(data_type):
+                            data_type = ElnBaseDataType.get_base_type(data_type).data_type_name
                         # Update the list of records of this type that exist so far globally.
                         self.__records.setdefault(data_type, set()).add(record)
                         # Do the same for the list of records of this type for this specific entry.
@@ -68,7 +95,37 @@ class ElnRuleHandler:
             # Update the records for this entry.
             self.__entry_to_records.update({entry: entry_dict})
 
-    def get_records(self, data_type: str, entry: str | None = None) -> list[DataRecord]:
+        self.__field_maps = {}
+        self.__entry_to_field_maps = {}
+        # Repeat the same thing for the field map results.
+        for entry, entry_results in self.__context.velox_eln_rule_field_map_result_map.items():
+            entry_dict: dict[str, dict[int, FieldMap]] = {}
+            for record_result in entry_results:
+                for result in record_result.velox_type_rule_field_map_result_list:
+                    data_type: str = result.velox_type_pojo.data_type_name
+                    if ElnBaseDataType.is_eln_type(data_type):
+                        data_type = ElnBaseDataType.get_base_type(data_type).data_type_name
+                    for field_map in result.field_map_list:
+                        rec_id: int = field_map.get("RecordId")
+                        self.__field_maps.setdefault(data_type, {}).update({rec_id: field_map})
+                        entry_dict.setdefault(data_type, {}).update({rec_id: field_map})
+            self.__entry_to_field_maps.update({entry: entry_dict})
+
+    def get_entry_names(self) -> list[str]:
+        """
+        :return: A list of the entry names that may be used with the get_records and get_models functions. These are the
+            entries from the experiment that the records in the rule context originate from.
+        """
+        return list(self.__entry_to_records.keys())
+
+    def get_field_maps_entry_names(self) -> list[str]:
+        """
+        :return: A list of the entry names that may be used with the get_field_maps function. These are the
+            entries from the experiment that the field maps in the rule context originate from.
+        """
+        return list(self.__entry_to_field_maps.keys())
+
+    def get_records(self, data_type: DataTypeIdentifier, entry: str | None = None) -> list[DataRecord]:
         """
         Get records from the cached context with the given data type. Capable of being filtered to searching within
         the context of an entry name. If the given data type or entry does not exist in the context,
@@ -79,9 +136,31 @@ class ElnRuleHandler:
             type from every entry. If an entry is provided, but it does not exist in the context, returns an empty list.
         :return: The records from the context that match the input parameters.
         """
+        data_type: str = AliasUtil.to_data_type_name(data_type)
         records: dict[str, set[DataRecord]] = self.__entry_to_records.get(entry, {}) if entry else self.__records
         return list(records.get(data_type, []))
 
+    # FR-46701: Add functions to the rule handlers for accessing the field maps of inaccessible records in the context.
+    def get_field_maps(self, data_type: DataTypeIdentifier, entry: str | None = None) -> list[FieldMap]:
+        """
+        Get field maps from the cached context with the given data type. Capable of being filtered to searching within
+        the context of an entry name. If the given data type or entry does not exist in the context,
+        returns an empty list.
+
+        Field maps will only exist in the context if the data record that the fields are from is no longer accessible
+        to the user. This can occur because the data record was deleted, or because the user does not have access to the
+        record due to ACL.
+
+        :param data_type: The data type of the field maps to return.
+        :param entry: The name of the entry to grab the field maps from. If None, returns the field maps that match the
+            data type from every entry. If an entry is provided, but it does not exist in the context, returns an empty
+            list.
+        :return: The field maps from the context that match the input parameters.
+        """
+        data_type: str = AliasUtil.to_data_type_name(data_type)
+        field_maps: dict[str, dict[int, FieldMap]] = self.__entry_to_field_maps.get(entry, {}) if entry else self.__field_maps
+        return list(field_maps.get(data_type, {}).values())
+
     def get_models(self, wrapper_type: type[WrappedType], entry: str | None = None) -> list[WrappedType]:
         """
         Get record models from the cached context with the given data type. Capable of being filtered to searching

sapiopycommons/rules/on_save_rule_handler.py

@@ -1,8 +1,15 @@
+from __future__ import annotations
+
+from weakref import WeakValueDictionary
+
+from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.DataRecord import DataRecord
+from sapiopylib.rest.pojo.eln.SapioELNEnums import ElnBaseDataType
 from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelManager, RecordModelInstanceManager
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 
+from sapiopycommons.general.aliases import FieldMap, DataTypeIdentifier, AliasUtil
 from sapiopycommons.general.exceptions import SapioException
 
 
@@ -10,7 +17,6 @@ from sapiopycommons.general.exceptions import SapioException
 class OnSaveRuleHandler:
     """
     A class which helps with the parsing and navigation of the on save rule result map of a webhook context.
-    TODO: Add functionality around the VeloxRuleType of the rule results.
     """
     __context: SapioWebhookContext
     """The context that this handler is working from."""
@@ -24,8 +30,33 @@ class OnSaveRuleHandler:
     __base_id_to_records: dict[int, dict[str, set[DataRecord]]]
     """A mapping of record IDs of records in the context.data_record_list to the sets of data records related to that
     record, each set of records being mapped by its data type."""
+    __field_maps: dict[str, dict[int, FieldMap]]
+    """A mapping of data type to the field maps from the context that match that data type. In order to prevent
+    duplicate field maps, each field map is in a dict keyed by the RecordId field in the field map, since field maps
+    are just dictionaries and dictionaries aren't hashable and therefore can't go in a set."""
+    __base_id_to_field_maps: dict[int, dict[str, dict[int, FieldMap]]]
+    """A mapping of record IDs of records in the context.data_record_list to the field maps related to that
+    record, each grouping of field maps being mapped by its data type."""
+
+    __instances: WeakValueDictionary[SapioUser, OnSaveRuleHandler] = WeakValueDictionary()
+    __initialized: bool
+
+    def __new__(cls, context: SapioWebhookContext):
+        if context.velox_on_save_result_map is None:
+            raise SapioException("No Velox on save rule result map in context for OnSaveRuleHandler to parse.")
+        user = context if isinstance(context, SapioUser) else context.user
+        obj = cls.__instances.get(user)
+        if not obj:
+            obj = object.__new__(cls)
+            obj.__initialized = False
+            cls.__instances[user] = obj
+        return obj
 
     def __init__(self, context: SapioWebhookContext):
+        if self.__initialized:
+            return
+        self.__initialized = True
+
         if context.velox_on_save_result_map is None:
             raise SapioException("No Velox on save rule result map in context for OnSaveRuleHandler to parse.")
         self.__context = context
@@ -42,9 +73,6 @@ class OnSaveRuleHandler:
         self.__base_id_to_records = {}
         # Each record ID in the context has a list of results for that record.
         for record_id, rule_results in self.__context.velox_on_save_result_map.items():
-            # TODO: Record IDs are currently being stored in the map as strings instead of ints. This can be removed
-            #  once sapiopylib is fixed.
-            record_id = int(record_id)
             # Keep track of the records for this specific record ID.
             id_dict: dict[str, set[DataRecord]] = {}
             # The list of results for a record consist of a list of data records and a VeloxType that specifies
@@ -55,12 +83,8 @@ class OnSaveRuleHandler:
                     # Get the data type of this record. If this is an ELN type, ignore the digits.
                     data_type: str = record.data_type_name
                     # PR-46331: Ensure that all ELN types are converted to their base data type name.
-                    if data_type.startswith("ELNExperiment_"):
-                        data_type = "ELNExperiment"
-                    elif data_type.startswith("ELNExperimentDetail_"):
-                        data_type = "ELNExperimentDetail"
-                    elif data_type.startswith("ELNSampleDetail_"):
-                        data_type = "ELNSampleDetail"
+                    if ElnBaseDataType.is_eln_type(data_type):
+                        data_type = ElnBaseDataType.get_base_type(data_type).data_type_name
                     # Update the list of records of this type that exist so far globally.
                     self.__records.setdefault(data_type, set()).add(record)
                     # Do the same for the list of records of this type that relate to this record ID.
@@ -68,7 +92,36 @@ class OnSaveRuleHandler:
             # Update the related records for this record ID.
             self.__base_id_to_records.update({record_id: id_dict})
 
-    def get_records(self, data_type: str, record_id: int | None = None) -> list[DataRecord]:
+        self.__field_maps = {}
+        self.__base_id_to_field_maps = {}
+        # Repeat the same thing for the field map results.
+        for record_id, rule_results in self.__context.velox_on_save_field_map_result_map.items():
+            id_dict: dict[str, dict[int, FieldMap]] = {}
+            for record_result in rule_results:
+                data_type: str = record_result.velox_type_pojo.data_type_name
+                if ElnBaseDataType.is_eln_type(data_type):
+                    data_type = ElnBaseDataType.get_base_type(data_type).data_type_name
+                for field_map in record_result.field_map_list:
+                    rec_id: int = field_map.get("RecordId")
+                    self.__field_maps.setdefault(data_type, {}).update({rec_id: field_map})
+                    id_dict.setdefault(data_type, {}).update({rec_id: field_map})
+            self.__base_id_to_field_maps.update({record_id: id_dict})
+
+    def get_base_record_ids(self) -> list[int]:
+        """
+        :return: A list of the record IDs that may be used with the get_records and get_models functions. These are the
+            record IDs to the records that caused the rule to trigger.
+        """
+        return list(self.__base_id_to_records.keys())
+
+    def get_field_maps_base_record_ids(self) -> list[int]:
+        """
+        :return: A list of the record IDs that may be used with the get_field_maps function. These are the
+            record IDs to the records that caused the rule to trigger.
+        """
+        return list(self.__base_id_to_field_maps.keys())
+
+    def get_records(self, data_type: DataTypeIdentifier, record_id: int | None = None) -> list[DataRecord]:
         """
         Get records from the cached context with the given data type. Capable of being filtered to searching within
         the context of a record ID. If the given data type or record ID does not exist in the context,
@@ -76,12 +129,34 @@ class OnSaveRuleHandler:
 
         :param data_type: The data type of the records to return.
         :param record_id: The record ID of the base record to search from. If None, returns the records that match the
-            data type from ID. If an ID is provided, but it does not exist in the context, returns an empty list.
+            data type from every ID. If an ID is provided, but it does not exist in the context, returns an empty list.
         :return: The records from the context that match the input parameters.
         """
+        data_type: str = AliasUtil.to_data_type_name(data_type)
         records: dict[str, set[DataRecord]] = self.__base_id_to_records.get(record_id, {}) if record_id else self.__records
         return list(records.get(data_type, []))
 
+    # FR-46701: Add functions to the rule handlers for accessing the field maps of inaccessible records in the context.
+    def get_field_maps(self, data_type: DataTypeIdentifier, record_id: int | None = None) -> list[FieldMap]:
+        """
+        Get field maps from the cached context with the given data type. Capable of being filtered to searching within
+        the context of a record ID. If the given data type or record ID does not exist in the context,
+        returns an empty list.
+
+        Field maps will only exist in the context if the data record that the fields are from is no longer accessible
+        to the user. This can occur because the data record was deleted, or because the user does not have access to the
+        record due to ACL.
+
+        :param data_type: The data type of the field maps to return.
+        :param record_id: The record ID of the base record to search from. If None, returns the field maps that match
+            the data type from every ID. If an ID is provided, but it does not exist in the context, returns an empty
+            list.
+        :return: The field maps from the context that match the input parameters.
+        """
+        data_type: str = AliasUtil.to_data_type_name(data_type)
+        field_maps: dict[str, dict[int, FieldMap]] = self.__base_id_to_field_maps.get(record_id, {}) if record_id else self.__field_maps
+        return list(field_maps.get(data_type, {}).values())
+
     def get_models(self, wrapper_type: type[WrappedType], record_id: int | None = None) -> list[WrappedType]:
         """
         Get records from the cached context with the given data type. Capable of being filtered to searching within

sapiopycommons/sftpconnect/sftp_builder.py

@@ -0,0 +1,70 @@
+import io
+from enum import Enum
+
+import paramiko
+from paramiko import pkey
+from paramiko.sftp_client import SFTPClient
+
+from sapiopycommons.general.exceptions import SapioException
+
+
+class SFTPAuthMethod(Enum):
+    """
+    An enum being used to specify connection type to the target server.
+    """
+    PASSWORD = 0
+    """Connection is being done via Password."""
+    FILEPATH = 1
+    """Connection is being done using a private key file in the codebase."""
+    KEY_STRING = 2
+    """Connection is being done using a private key in string form."""
+
+
+class SFTPBuilder:
+    """
+    A class for making SFTP connections.
+    """
+
+    @staticmethod
+    def open_sftp(username: str, host: str, port: int, authentication: str,
+                  connection_type: SFTPAuthMethod = SFTPAuthMethod.PASSWORD) -> SFTPClient:
+        """
+        Builds a SFTP client from user input.
+
+        :param username: The username of the individual trying to connect to the target server.
+        :param host: The hostname/IP address of the target server.
+        :param port: The port number used to connect to the target server.
+        :param authentication: The string used to connect to the target server. This could hold a filepath, a password
+            or a private key in string form depending on the connection_type parameter.
+
+            If authentication is a private key string, they are generally formated like this:
+            -----BEGIN OPENSSH PRIVATE KEY-----\n
+            asdfh;hjadfh;jghajdg54646+5fasdfadlajklgajd'gj'ajg654564\n
+            asdkjfhj;kghj;ahj;wh41234hjadjkhhdsgadshjkdghjshdlsds468\n
+            ....
+
+        :param connection_type: This enum is used to specify how the connection to the target server is being made.
+            The options are:
+            (0) PASSWORD: This means that the authentication parameter contains a password that will be used to connect to the server
+            (1) FILEPATH: This means that the authentication parameter contains a filepath leading to a private key file stored in the codebase
+            (2) KEY_STRING: This means that the authentication parameter contains the private key in string form
+
+        """
+
+        client = paramiko.SSHClient()
+        client.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy)
+
+        if connection_type == SFTPAuthMethod.FILEPATH:
+            client.connect(host, username=username, port=port, key_filename=authentication)
+            return client.open_sftp()
+
+        if connection_type == SFTPAuthMethod.KEY_STRING:
+            private_key: pkey = paramiko.RSAKey.from_private_key(io.StringIO(authentication))
+            client.connect(host, username=username, port=port, pkey=private_key)
+            return client.open_sftp()
+
+        if connection_type == SFTPAuthMethod.PASSWORD:
+            client.connect(host, username=username, password=authentication, port=port)
+            return client.open_sftp()
+
+        raise SapioException("The SFTPAuthMethod enumerator was not properly specified.")

sapiopycommons/webhook/webhook_context.py

@@ -0,0 +1,39 @@
+import json
+from typing import Any
+
+from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
+
+
+class CustomWebhookContext(SapioWebhookContext):
+    """
+    CustomWebhookContext is a wrapper for the default SapioWebhookContext to be used by custom invocation types to
+    convert the context_data that the server sends from a JSON string to usable parameters. This class works as a
+    middleman to cleanly convert a SapioWebhookContext object into a CustomWebhookContext by copying all the parameters
+    of the given context into the custom context.
+    """
+    def __init__(self, context: SapioWebhookContext):
+        # Use __dict__ so that we don't need t maintain this class due to future changes to SapioWebhookContext.
+        self.__dict__ = context.__dict__
+        super().__init__(self.user, self.end_point_type)
+
+
+class ProcessQueueContext(CustomWebhookContext):
+    """
+    When a custom process queue endpoint is invoked, the context from the queue is sent in a context_data parameter
+    on the SapioWebhookContext object, stored as a JSON string. This class parses that JSON into fields for the
+    caller to make use of.
+    """
+    process_name: str
+    """The name of the process that the user invoked this webhook from."""
+    step_name: str
+    """The name of the step in the process that the user invoked this webhook from."""
+    process_queue_item_record_ids: list[int]
+    """The record IDs of the process queue items related to the records that were selected by the user when this
+    webhook was invoked."""
+
+    def __init__(self, context: SapioWebhookContext):
+        super().__init__(context)
+        context_data: dict[str, Any] = json.loads(self.context_data)
+        self.process_name = context_data["processName"]
+        self.step_name = context_data["workflowName"]
+        self.process_queue_item_record_ids = context_data["processQueueItemRecordIds"]