sapiopycommons 2025.5.6a512__py3-none-any.whl → 2025.5.7a514__py3-none-any.whl

sapiopycommons/eln/step_creation.py

@@ -0,0 +1,236 @@
+from typing import Iterable
+
+from sapiopycommons.general.aliases import DataTypeIdentifier, FieldIdentifier, ExperimentEntryIdentifier
+from sapiopylib.rest.pojo.TableColumn import TableColumn
+from sapiopylib.rest.pojo.datatype.FieldDefinition import AbstractVeloxFieldDefinition
+from sapiopylib.rest.pojo.eln.SapioELNEnums import ExperimentEntryStatus, ElnEntryType
+from sapiopylib.rest.pojo.eln.field_set import ElnFieldSetInfo
+
+
+# CR-47564: Created these classes to streamline entry creation using the ExperimentEntryFactory.
+class StepCreation:
+    """
+    An object that contains the criteria for creating a new entry in the experiment.
+    """
+    _entry_type: ElnEntryType
+    """The type of the entry to be created."""
+    is_shown_in_template: bool | None
+    """Whether the entry will appear in the template if the experiment this entry is in is saved to a new template."""
+    is_removable: bool | None
+    """Whether the entry can be removed by users."""
+    is_renamable: bool | None
+    """Whether the entry can be renamed by users."""
+    is_static_view: bool | None
+    """Whether the entry's attachment is static. For attachment entries only. Static attachment entries will store
+    their attachment data in the template."""
+    related_entry_set: Iterable[ExperimentEntryIdentifier | str] | None
+    """The IDs of the entries this entry is implicitly dependent on. If any of the entries are deleted then this entry
+    is also deleted."""
+    dependency_set: Iterable[ExperimentEntryIdentifier | str] | None
+    """The IDs of the entries this entry is dependent on. Requires the entries to be completed before this entry will
+    be enabled."""
+    requires_grabber_plugin: bool
+    """Whether to run a grabber plugin when this entry is initialized."""
+    entry_singleton_id: str | None
+    """When this field is present (i.e. not null or blank) it will enforce that only one entry with this singleton
+    value is present in the experiment. If you attempt to create an entry with the singletonId of an entry already
+    present in the experiment it will return the existing entry instead of creating a new one. If an entry isn't
+    present in the Notebook Experiment with a matching singletonId it will create a new entry like normal."""
+    is_hidden: bool | None
+    """Whether the user is able to visibly see this entry within the experiment."""
+    entry_height: int | None
+    """The height of this entry in pixels. Setting the height to 0 will cause the entry to auto-size to its contents."""
+    description: str | None
+    """The description of the entry."""
+    is_initialization_required: bool | None
+    """Whether the user must manually initialize this entry by clicking on it."""
+    collapse_entry: bool | None
+    """Whether the entry should be collapsed by default."""
+    entry_status: ExperimentEntryStatus | None
+    """The current status of the entry."""
+    template_item_fulfilled_timestamp: int | None
+    """The time in milliseconds since the epoch that this entry became initialized."""
+    entry_options: dict[str, str] | None
+    """The entry options of the entry."""
+
+    def __init__(self, entry_type: ElnEntryType):
+        self._entry_type = entry_type
+        self.is_shown_in_template = None
+        self.is_removable = None
+        self.is_renamable = None
+        self.is_static_view = None
+        self.related_entry_set = None
+        self.dependency_set = None
+        self.requires_grabber_plugin = False
+        self.entry_singleton_id = None
+        self.is_hidden = None
+        self.entry_height = None
+        self.description = None
+        self.is_initialization_required = None
+        self.collapse_entry = None
+        self.entry_status = None
+        self.template_item_fulfilled_timestamp = None
+        self.entry_options = None
+
+    @property
+    def entry_type(self) -> ElnEntryType:
+        return self._entry_type
+
+class AttachmentStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new attachment entry in an experiment.
+    """
+    def __init__(self):
+        super().__init__(ElnEntryType.Attachment)
+
+
+class DashboardStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new dashboard entry in an experiment.
+    """
+    source_entry: ExperimentEntryIdentifier | str | None
+    """The entry that contains the source data for this entry's dashboard(s)."""
+    dashboard_guids: Iterable[str] | None
+    """The GUIDs of the dashboards to display in this entry."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.Dashboard)
+        self.source_entry = None
+        self.dashboard_guids = None
+
+
+class GlobalDtFormStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new global data type form entry in an experiment.
+    """
+    layout_name: str | None
+    """The name of the data type layout to be displayed in this form. The layout must be for the data type for this
+    entry."""
+    form_names: Iterable[str] | None
+    """The names of the components in the chosen data type layout to display in this form."""
+    extension_types: Iterable[DataTypeIdentifier] | None
+    """The names of the extension data types to display fields from within the form."""
+    field_names: Iterable[FieldIdentifier] | None
+    """A list of data field names for the fields to be displayed in the form."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.Form)
+        self.form_names = None
+        self.layout_name = None
+        self.extension_types = None
+        self.field_names = None
+
+
+class ELnDtFormStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new ELN data type form entry in an experiment.
+    """
+    is_field_addable: bool | None
+    """Whether new fields can be added to the entry by users."""
+    is_existing_field_removable: bool | None
+    """Whether existing fields on the entry can be removed by users."""
+    field_sets: Iterable[int | str | ElnFieldSetInfo] | None
+    """The predefined field sets to display in this form."""
+    field_definitions: Iterable[AbstractVeloxFieldDefinition] | None
+    """New field definitions to be created for this entry."""
+    predefined_field_names: Iterable[str] | None
+    """The names of the predefined fields to display in this form."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.Form)
+        self.is_field_addable = None
+        self.is_existing_field_removable = None
+        self.field_sets = None
+        self.field_definitions = None
+        self.predefined_field_names = None
+        self.table_columns = None
+
+
+class PluginStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new plugin entry in an experiment.
+    """
+    plugin_name: str | None
+    """The client side plugin name to render this entry with."""
+    using_template_data: bool | None
+    """Whether this entry will use the data from the template."""
+    provides_template_data: bool | None
+    """Whether this entry can provide data to copy into a new template."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.Plugin)
+        self.plugin_name = None
+        self.using_template_data = None
+        self.provides_template_data = None
+
+
+class GlobalDtTableStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new global data type table entry in an experiment.
+    """
+    layout_name: str | None
+    """The name of the data type layout to display in this table."""
+    extension_types: Iterable[str] | None
+    """The names of the extension data types to display fields from within the table."""
+    table_columns: Iterable[TableColumn] | None
+    """The columns to display in the table. This can be used to change the sort order and direction of columns."""
+    field_names: Iterable[FieldIdentifier] | None
+    """A list of data field names for the fields to be displayed in the table. These will be added as TableColumns and
+    placed after any of the existing columns specified in the table_columns parameter without any sorting."""
+    show_key_fields: bool | None
+    """Whether the key fields of the data type should be shown in the entry."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.Table)
+        self.layout_name = None
+        self.extension_types = None
+        self.table_columns = None
+        self.field_names = None
+        self.show_key_fields = None
+
+
+class ELnDtTableStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new ELN data type table entry in an experiment.
+    """
+    is_field_addable: bool | None
+    """Whether new fields can be added to the entry by users."""
+    is_existing_field_removable: bool | None
+    """Whether existing fields on the entry can be removed by users."""
+    field_sets: Iterable[int | str | ElnFieldSetInfo] | None
+    """The predefined field sets to display in this form."""
+    field_definitions: Iterable[AbstractVeloxFieldDefinition] | None
+    """New field definitions to be created for this entry."""
+    predefined_field_names: Iterable[str] | None
+    """The names of the predefined fields to display in this form."""
+    table_columns: Iterable[TableColumn] | None
+    """The columns to display in the table."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.Table)
+        self.is_field_addable = None
+        self.is_existing_field_removable = None
+        self.field_sets = None
+        self.field_definitions = None
+        self.predefined_field_names = None
+        self.table_columns = None
+
+
+class TempDataStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new temp data entry in an experiment.
+    """
+    plugin_path: str | None
+    """The temp data plugin path to run to populate the entry."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.TempData)
+        self.plugin_path = None
+
+
+class TextStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new text entry in an experiment.
+    """
+    def __init__(self):
+        super().__init__(ElnEntryType.Text)

sapiopycommons/files/file_util.py

@@ -327,10 +327,10 @@ class FileUtil:
         :param files: A dictionary of file name to file data as a string or bytes.
         :return: The bytes for a zip file containing the input files.
         """
-        zip_buffer: io.BytesIO = io.BytesIO()
-        with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
-            for file_name, file_data in files.items():
-                zip_file.writestr(file_name, file_data)
+        with io.BytesIO() as zip_buffer:
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
+                for file_name, file_data in files.items():
+                    zip_file.writestr(file_name, file_data)
         return zip_buffer.getvalue()
 
     # Deprecated functions:

sapiopycommons/general/accession_service.py

@@ -199,7 +199,7 @@ class AccessionRequestId(AbstractAccessionServiceOperator):
 
     Properties:
         numberOfCharacters: Number of characters maximum in the request ID.
-        accessorName: This is a legacy variable from drum.getNextIdListByMapName(), which allows setting different "accessorName" from old system. We need this for compability patch for converting these to the new preference format.
+        accessorName: This is a legacy variable from drum.getNextIdListByMapName(), which allows setting different "accessorName" from old system. We need this for compatibility patch for converting these to the new preference format.
     """
     _num_of_characters: int
     _accessor_name: str
@@ -341,7 +341,7 @@ class AccessionService:
     def get_affixed_id_in_batch(self, data_type_name: str, data_field_name: str, num_ids: int, prefix: str | None,
                                 suffix: str | None, num_digits: int | None, start_num: int = 1) -> list[str]:
         """
-        Get the batch affixed IDs that are maximal in cache and contiguious for a particular datatype.datafield under a given format.
+        Get the batch affixed IDs that are maximal in cache and contiguous for a particular datatype.datafield under a given format.
         :param data_type_name: The datatype name to look for max ID
         :param data_field_name: The datafield name to look for max ID
         :param num_ids: The number of IDs to accession.

sapiopycommons/general/aliases.py

@@ -7,6 +7,7 @@ from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType, AbstractVel
 from sapiopylib.rest.pojo.eln.ElnExperiment import ElnExperiment
 from sapiopylib.rest.pojo.eln.ExperimentEntry import ExperimentEntry
 from sapiopylib.rest.pojo.eln.SapioELNEnums import ElnBaseDataType
+from sapiopylib.rest.pojo.eln.eln_headings import ElnExperimentTab
 from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.utils.Protocols import ElnExperimentProtocol, ElnEntryStep
 from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel, AbstractRecordModel
@@ -219,7 +220,9 @@ class AliasUtil:
             # noinspection PyTypeChecker
             fields: FieldMap = record.get_fields()
         else:
-            fields: FieldMap = record.fields.copy_to_dict()
+            # TI-47593: Copy the record's fields by using the get() method instead of copy_to_dict() so that date
+            # macros get translated to valid field values.
+            fields: FieldMap = {f: record.fields.get(f) for f in record.fields}
         # PR-47457: Only include the record ID if the caller requests it, since including the record ID can break
         # callbacks in certain circumstances if the record ID is negative.
         if include_record_id:

sapiopycommons/general/data_structure_util.py

@@ -0,0 +1,115 @@
+from enum import Enum
+from typing import Iterable, Any, Collection
+
+from sapiopycommons.general.exceptions import SapioException
+
+
+class ArrayTransformation(Enum):
+    """
+    An enumeration of the different transformations that can be applied to a 2D array.
+    """
+    ROTATE_CLOCKWISE = 0
+    ROTATE_COUNTER_CLOCKWISE = 1
+    ROTATE_180_DEGREES = 2
+    MIRROR_HORIZONTAL = 3
+    MIRROR_VERTICAL = 4
+
+
+# FR-47524: Create a DataStructureUtils class that implements various collection utility functions from our Java
+# libraries.
+class DataStructureUtil:
+    """
+    Utility class for working with data structures. Copies from ListUtil, SetUtil, and various other classes in
+    our Java library.
+    """
+    @staticmethod
+    def find_first_or_none(values: Iterable[Any]) -> Any | None:
+        """
+        Get the first value from an iterable, or None if the iterable is empty.
+
+        :param values: An iterable of values.
+        :return: The first value from the input, or None if the input is empty.
+        """
+        return next(iter(values), None)
+
+    @staticmethod
+    def remove_null_values(values: Iterable[Any]) -> list[Any]:
+        """
+        Remove null values from a list.
+
+        :param values: An iterable of values.
+        :return: A list containing all the non-null values from the input.
+        """
+        return [value for value in values if value is not None]
+
+    @staticmethod
+    def transform_2d_array(values: Collection[Collection[Any]], transformation: ArrayTransformation) \
+            -> Collection[Collection[Any]]:
+        """
+        Perform a transformation on a 2D list.
+
+        :param values: An iterable of iterables. The iterables should all be of the same size.
+        :param transformation: The transformation to apply to the input.
+        :return: A new 2D list containing the input transformed according to the specified transformation.
+        """
+        x: int = len(values)
+        for row in values:
+            y = len(row)
+            if y != x:
+                raise SapioException(f"Input must be a square 2D array. The provided array has a length of {x} but "
+                                     f"at least one row has a length of {y}.")
+
+        match transformation:
+            case ArrayTransformation.ROTATE_CLOCKWISE:
+                return [list(row) for row in zip(*values[::-1])]
+            case ArrayTransformation.ROTATE_COUNTER_CLOCKWISE:
+                return [list(row) for row in zip(*values)][::-1]
+            case ArrayTransformation.ROTATE_180_DEGREES:
+                return [row[::-1] for row in values[::-1]]
+            case ArrayTransformation.MIRROR_HORIZONTAL:
+                return [list(row[::-1]) for row in values]
+            case ArrayTransformation.MIRROR_VERTICAL:
+                return values[::-1]
+
+        raise SapioException(f"Invalid transformation: {transformation}")
+
+    @staticmethod
+    def flatten_to_list(values: Iterable[Iterable[Any]]) -> list[Any]:
+        """
+        Flatten a list of lists into a single list.
+
+        :param values: An iterable of iterables.
+        :return: A single list containing all the values from the input. Elements are in the order they appear in the
+            input.
+        """
+        return [item for sublist in values for item in sublist]
+
+    @staticmethod
+    def flatten_to_set(values: Iterable[Iterable[Any]]) -> set[Any]:
+        """
+        Flatten a list of lists into a single set.
+
+        :param values: An iterable of iterables.
+        :return: A single set containing all the values from the input. Elements are in the order they appear in the
+            input.
+        """
+        return {item for subset in values for item in subset}
+
+    @staticmethod
+    def invert_dictionary(dictionary: dict[Any, Any], list_values: bool = False) \
+            -> dict[Any, Any] | dict[Any, list[Any]]:
+        """
+        Invert a dictionary, swapping keys and values. Note that the values of the input dictionary must be hashable.
+
+        :param dictionary: A dictionary to invert.
+        :param list_values: If false, keys that share the same value in the input dictionary will be overwritten in
+            the output dictionary so that only the last key remains. If true, the values of the output dictionary will
+            be lists where input keys that share the same value will be stored together.
+        :return: A new dictionary with the keys and values swapped.
+        """
+        if list_values:
+            inverted = {}
+            for key, value in dictionary.items():
+                inverted.setdefault(value, []).append(key)
+            return inverted
+        return {value: key for key, value in dictionary.items()}

sapiopycommons/general/sapio_links.py

@@ -10,8 +10,7 @@ class SapioNavigationLinker:
     Given a URL to a system's webservice API (example: https://company.exemplareln.com/webservice/api), construct
     URLs for navigation links to various locations in the system.
     """
-    client_url: str
-    webservice_url: str
+    base_url: str
 
     def __init__(self, url: str | SapioUser | SapioWebhookContext):
         """
@@ -22,14 +21,7 @@ class SapioNavigationLinker:
             url = url.user.url
         elif isinstance(url, SapioUser):
             url = url.url
-        self.webservice_url = url.rstrip("/")
-        self.client_url = url.rstrip("/").replace('webservice/api', 'veloxClient')
-
-    def homepage(self) -> str:
-        """
-        :return: A URL for navigating to the system's homepage.
-        """
-        return self.client_url + "/#view=homepage"
+        self.base_url = url.rstrip("/").replace('webservice/api', 'veloxClient')
 
     def data_record(self, record_identifier: RecordIdentifier, data_type_name: DataTypeIdentifier | None = None) -> str:
         """
@@ -47,7 +39,7 @@ class SapioNavigationLinker:
         if not data_type_name:
             raise SapioException("Unable to create a data record link without a data type name. "
                                  "Only a record ID was provided.")
-        return self.client_url + f"/#dataType={data_type_name};recordId={record_id};view=dataRecord"
+        return self.base_url + f"/#dataType={data_type_name};recordId={record_id};view=dataRecord"
 
     def experiment(self, experiment: ExperimentIdentifier) -> str:
         """
@@ -55,4 +47,4 @@ class SapioNavigationLinker:
             object, experiment protocol, or a notebook ID.
         :return: A URL for navigating to the input experiment.
         """
-        return self.client_url + f"/#notebookExperimentId={AliasUtil.to_notebook_id(experiment)};view=eln"
+        return self.base_url + f"/#notebookExperimentId={AliasUtil.to_notebook_id(experiment)};view=eln"

sapiopycommons/processtracking/custom_workflow_handler.py

@@ -105,7 +105,8 @@ class QueueItemHandler:
         """
         self.user = AliasUtil.to_sapio_user(context)
         self.rec_handler = RecordHandler(self.user)
-        if isinstance(context, SapioWebhookContext):
+        # PR-47565: Only initialize a ProcessQueueContext if the given context object has context_data.
+        if isinstance(context, SapioWebhookContext) and context.context_data:
             self.context = ProcessQueueContext(context)
         else:
             self.context = None