sapiopycommons 2024.10.29a346__py3-none-any.whl → 2024.10.30a348__py3-none-any.whl

sapiopycommons/callbacks/field_builder.py

@@ -0,0 +1,537 @@
+from sapiopylib.rest.pojo.DateRange import DateRange
+from sapiopylib.rest.pojo.Sort import SortDirection
+from sapiopylib.rest.pojo.datatype.FieldDefinition import VeloxStringFieldDefinition, SapioStringFormat, \
+    FieldValidator, VeloxAccessionFieldDefinition, VeloxBooleanFieldDefinition, VeloxDateFieldDefinition, \
+    VeloxDateRangeFieldDefinition, VeloxDoubleFieldDefinition, VeloxEnumFieldDefinition, VeloxIntegerFieldDefinition, \
+    VeloxLongFieldDefinition, VeloxPickListFieldDefinition, VeloxSelectionFieldDefinition, VeloxShortFieldDefinition, \
+    SapioDoubleFormat, ListMode
+
+from sapiopycommons.general.exceptions import SapioException
+
+
+class AnyFieldInfo:
+    """
+    Field definition information that can apply to any created field def. This excludes various members of
+    AbstractVeloxFieldDefinition such as system_field that wouldn't make sense to edit for a created field def
+    used in a temp data type.
+    """
+    editable: bool
+    required: bool
+    visible: bool
+    description: str | None
+    sort_direction: SortDirection | None
+    sort_order: int | None
+    default_table_column_width: int | None
+
+    def __init__(self, editable: bool = True, required: bool = False, visible: bool = True,
+                 description: str | None = None, sort_direction: SortDirection | None = None,
+                 sort_order: int | None = None, default_table_column_width: int | None = None):
+        """
+        :param editable: Whether this field can be edited by the user.
+        :param required: Whether input is required for this field before the user can submit the dialog that it is a
+            part of.
+        :param visible: Whether this field is visible to the user.
+        :param description: The description of this field that will appear when the user hovers the cursor over it.
+        :param sort_direction: The default sort direction of this field in tables. The user may still change the column
+            sorting.
+        :param sort_order: The default sort order of this field in tables. The user may still change the column sorting.
+        :param default_table_column_width: The width in pixels that this field's column will appear with in tables by
+            default. The user may still change the column width.
+        """
+        self.editable = editable
+        self.required = required
+        self.visible = visible
+        self.description = description
+        self.sort_direction = sort_direction
+        self.sort_order = sort_order
+        self.default_table_column_width = default_table_column_width
+
+
+class FieldBuilder:
+    """
+    A class used for building fields for temporary data types. Currently designed to only create fields which can
+    be used in client callbacks that use temp data types. Some fields will not be displayed in temp data types,
+    including but not limited to: action fields, child/parent/side link fields.
+    """
+    data_type: str
+
+    def __init__(self, data_type: str = "Default"):
+        """
+        :param data_type: The data type name that fields created from this builder will use as their data type.
+        """
+        self.data_type = data_type
+
+    def accession_field(self, field_name: str, sequence_key: str, prefix: str | None = None, suffix: str | None = None,
+                        number_of_digits: int = 8, starting_value: int = 1, link_out: dict[str, str] | None = None,
+                        abstract_info: AnyFieldInfo | None = None, *, data_type_name: str | None = None,
+                        display_name: str | None = None) -> VeloxAccessionFieldDefinition:
+        """
+        Create an accession field definition. Accession fields are text fields which generate a unique value
+        that has not been used before, incrementing from the most recently generated value. This can be used when a
+        guaranteed unique ID is necessary.
+    
+        :param field_name: The data field name of this field. Unless a display name is also provided, this doubles as
+            the display name.
+        :param sequence_key: The key of the accession sequence that this field will use.
+        :param prefix: The text that should appear before the numerical value.
+        :param suffix: The text that should appear after the numerical value.
+        :param number_of_digits: The number of digits in the numerical value.
+        :param starting_value: The starting value of the numerical value.
+        :param link_out: A dictionary where the keys are the display names of the links and the values are the links to
+            navigate the user to if this field is clicked on. If the values contain the string "[[LINK_OUT]]" then that
+            macro will be replaced with the value of the string field when it is clicked. The display name is only
+            important if there is more than one link in the dictionary, in which case all available link out locations
+            will display in a dialog with their display names for the user to select. If a non-empty dictionary is
+            provided, this becomes a link-out field.
+            If the value is not determined to have the appearance of a URL (e.g. it doesn't start with https://), then
+            the system will prepend "https://<app-url>/veloxClient/" to the start of the URL. This allows you to create
+            links to other locations in the system without needing to know what the app URL is. For example, if you have
+            a link out string field that contains a record ID to a Sample, you could set the link value to
+            "#dataType=Sample;recordId=[[LINK_OUT]];view=dataRecord" and the client will, seeing that this is not a
+            normal looking URL, route the user to
+            https://<app-url>/veloxClient/#dataType=Sample;recordId=[[LINK_OUT]];view=dataRecord, which is the form
+            page of the Sample corresponding to the record ID recorded by the field value.
+        :param abstract_info: The abstract field info for this field, such as whether it is editable or required.
+        :param data_type_name: An optional override for the data type name used for this field. If not provided, then
+            the data field name of the FieldBuilder is used.
+        :param display_name: An optional override for the display name of this field. If not provided, then the data
+            field name doubles as the display name.
+        :return: An accession field definition with settings from the input criteria.
+        """
+        if abstract_info is None:
+            abstract_info = AnyFieldInfo()
+        if not data_type_name:
+            data_type_name = self.data_type
+        if not display_name:
+            display_name = field_name
+        # Accession fields lock editable to false.
+        abstract_info.editable = False
+        link_out, link_out_url = self._convert_link_out(link_out)
+        # The unique parameter has no effect, so just always set it to false.
+        return VeloxAccessionFieldDefinition(data_type_name, field_name, display_name, sequence_key, prefix, suffix,
+                                             number_of_digits, False, starting_value, link_out, link_out_url,
+                                             kwargs=abstract_info.__dict__)
+
+    def boolean_field(self, field_name: str, default_value: bool | None = False, abstract_info: AnyFieldInfo | None = None,
+                      *, data_type_name: str | None = None, display_name: str | None = None) -> VeloxBooleanFieldDefinition:
+        """
+        Create a boolean field definition. Boolean fields are fields which may have a value of true or false.
+        They appear as a checkbox in the UI. Boolean fields may also have a value of null if the field is not required.
+
+        :param field_name: The data field name of this field. Unless a display name is also provided, this doubles as
+            the display name.
+        :param default_value: The default value to display in this field before the user edits it.
+        :param abstract_info: The abstract field info for this field, such as whether it is editable or required.
+        :param data_type_name: An optional override for the data type name used for this field. If not provided, then
+            the data field name of the FieldBuilder is used.
+        :param display_name: An optional override for the display name of this field. If not provided, then the data
+            field name doubles as the display name.
+        :return: A boolean field definition with settings from the input criteria.
+        """
+        if abstract_info is None:
+            abstract_info = AnyFieldInfo()
+            # Boolean fields assume that they are required if no abstract info is provided.
+            abstract_info.required = True
+        if not data_type_name:
+            data_type_name = self.data_type
+        if not display_name:
+            display_name = field_name
+        return VeloxBooleanFieldDefinition(data_type_name, field_name, display_name, default_value,
+                                           kwargs=abstract_info.__dict__)
+
+    def date_field(self, field_name: str, default_value: int | None = None, date_time_format: str = "MMM dd, yyyy",
+                   static_date: bool = False, abstract_info: AnyFieldInfo | None = None, *,
+                   data_type_name: str | None = None, display_name: str | None = None) -> VeloxDateFieldDefinition:
+        """
+        Create a date field definition. Date fields store date and time information as an integer
+        representing the number of milliseconds since the unix epoch. This timestamp is then displayed to users in a
+        human-readable format.
+
+        :param field_name: The data field name of this field. Unless a display name is also provided, this doubles as
+            the display name.
+        :param default_value: The default value to display in this field before the user edits it.
+        :param date_time_format: The format that this date field should appear in. The date format is Java-style.
+            See https://docs.oracle.com/en/java/javase/18/docs/api/java.base/java/text/SimpleDateFormat.html for more
+            details.
+        :param static_date: If true, this date displays in UTC regardless of the user's timezone. If false, this date
+            displays the time in the user's timezone.
+        :param abstract_info: The abstract field info for this field, such as whether it is editable or required.
+        :param data_type_name: An optional override for the data type name used for this field. If not provided, then
+            the data field name of the FieldBuilder is used.
+        :param display_name: An optional override for the display name of this field. If not provided, then the data
+            field name doubles as the display name.
+        :return: A date field definition with settings from the input criteria.
+        """
+        if abstract_info is None:
+            abstract_info = AnyFieldInfo()
+        if not data_type_name:
+            data_type_name = self.data_type
+        if not display_name:
+            display_name = field_name
+        return VeloxDateFieldDefinition(data_type_name, field_name, display_name, date_time_format, default_value,
+                                        static_date, kwargs=abstract_info.__dict__)
+
+    def date_range_field(self, field_name: str, default_value: str | DateRange | None = None,
+                         date_time_format: str = "MMM dd, yyyy", static_date: bool = False,
+                         abstract_info: AnyFieldInfo | None = None, *, data_type_name: str | None = None,
+                         display_name: str | None = None) -> VeloxDateRangeFieldDefinition:
+        """
+        Create a date range field definition. Date range fields store two unix epoch timestamps as a string of the
+        format "[start timestamp]/[end timestamp]". This string is then displayed to users in a human-readable
+        format as two dates.
+
+        See the DateRange class from sapiopylib for an easy means of converting to/from millisecond timestamps and a
+        date range field's string value.
+
+        :param field_name: The data field name of this field. Unless a display name is also provided, this doubles as
+            the display name.
+        :param default_value: The default value to display in this field before the user edits it.
+        :param date_time_format: The format that this date field should appear in. The date format is Java-style.
+            See https://docs.oracle.com/en/java/javase/18/docs/api/java.base/java/text/SimpleDateFormat.html for more
+            details.
+        :param static_date: If true, these dates display in UTC regardless of the user's timezone. If false, they
+            display the time in the user's timezone.
+        :param abstract_info: The abstract field info for this field, such as whether it is editable or required.
+        :param data_type_name: An optional override for the data type name used for this field. If not provided, then
+            the data field name of the FieldBuilder is used.
+        :param display_name: An optional override for the display name of this field. If not provided, then the data
+            field name doubles as the display name.
+        :return: A date range field definition with settings from the input criteria.
+        """
+        if abstract_info is None:
+            abstract_info = AnyFieldInfo()
+        if not data_type_name:
+            data_type_name = self.data_type
+        if not display_name:
+            display_name = field_name
+        if isinstance(default_value, DateRange):
+            default_value = str(default_value)
+        return VeloxDateRangeFieldDefinition(data_type_name, field_name, display_name, date_time_format, static_date,
+                                             default_value, kwargs=abstract_info.__dict__)
+
+    def double_field(self, field_name: str, default_value: float | None = None, min_value: float = -10.**120,
+                     max_value: float = 10.**120, precision: int = 1, double_format: SapioDoubleFormat | None = None,
+                     abstract_info: AnyFieldInfo | None = None, *, data_type_name: str | None = None,
+                     display_name: str | None = None) -> VeloxDoubleFieldDefinition:
+        """
+        Create a double field definition. Double fields represent decimal numerical values. They can also
+        be configured to represent currencies or percentages by changing the format parameter.
+
+        :param field_name: The data field name of this field. Unless a display name is also provided, this doubles as
+            the display name.
+        :param default_value: The default value to display in this field before the user edits it.
+        :param min_value: The minimum allowed value in this field.
+        :param max_value: The maximum allowed value in this field.
+        :param precision: The number of digits past the decimal point to display for this field.
+        :param double_format: The format that this double field is displayed in. If no value is provided, the field
+            display as a normal numerical value.
+        :param abstract_info: The abstract field info for this field, such as whether it is editable or required.
+        :param data_type_name: An optional override for the data type name used for this field. If not provided, then
+            the data field name of the FieldBuilder is used.
+        :param display_name: An optional override for the display name of this field. If not provided, then the data
+            field name doubles as the display name.
+        :return: A double field definition with settings from the input criteria.
+        """
+        if abstract_info is None:
+            abstract_info = AnyFieldInfo()
+        if not data_type_name:
+            data_type_name = self.data_type
+        if not display_name:
+            display_name = field_name
+        return VeloxDoubleFieldDefinition(data_type_name, field_name, display_name, min_value, max_value, default_value,
+                                          precision, double_format, kwargs=abstract_info.__dict__)
+
+    def enum_field(self, field_name: str, options: list[str], default_value: int | None = None,
+                   abstract_info: AnyFieldInfo | None = None, *, data_type_name: str | None = None,
+                   display_name: str | None = None) -> VeloxEnumFieldDefinition:
+        """
+        Create an enum field definition. Enum fields allow for the display of a list of options as a field
+        definition without the need of a backing method in the system like pick list or selection lists do. Note that
+        when setting the default value or reading the return value of an enum field, the value is an integer
+        representing the index of the values list, as opposed to a string for the exact value chosen.
+
+        Note that this field is mainly here for completeness' sake. You can now use the static_values parameter of a
+        selection list to achieve the same thing without needing to worry about the field value being the index of the
+        options.
+
+        :param field_name: The data field name of this field. Unless a display name is also provided, this doubles as
+            the display name.
+        :param options: The list of strings that the user may select from for this enum field. Note that when a client
+            callback returns the value from an enum field, it will be the index of the option in the options list that
+            the user chose.
+        :param default_value: The default value to display in this field before the user edits it. This is the index of
+            the option from the options list that you wish to appear as the default.
+        :param abstract_info: The abstract field info for this field, such as whether it is editable or required.
+        :param data_type_name: An optional override for the data type name used for this field. If not provided, then
+            the data field name of the FieldBuilder is used.
+        :param display_name: An optional override for the display name of this field. If not provided, then the data
+            field name doubles as the display name.
+        :return: An enum field definition with settings from the input criteria.
+        """
+        if abstract_info is None:
+            abstract_info = AnyFieldInfo()
+        if not data_type_name:
+            data_type_name = self.data_type
+        if not display_name:
+            display_name = field_name
+        return VeloxEnumFieldDefinition(data_type_name, field_name, display_name, default_value, options,
+                                        kwargs=abstract_info.__dict__)
+
+    def int_field(self, field_name: str, default_value: int | None = None, min_value: int = -2**31,
+                  max_value: int = 2**31 - 1, unique_value: bool = False, abstract_info: AnyFieldInfo | None = None, *,
+                  data_type_name: str | None = None, display_name: str | None = None) -> VeloxIntegerFieldDefinition:
+        """
+        Create an integer field definition. Integer fields are 32-bit whole numbers.
+
+        :param field_name: The data field name of this field. Unless a display name is also provided, this doubles as
+            the display name.
+        :param default_value: The default value to display in this field before the user edits it.
+        :param min_value: The minimum allowed value in this field.
+        :param max_value: The maximum allowed value in this field.
+        :param unique_value: Whether the value in this field must be unique across all temp records in the dialog.
+        :param abstract_info: The abstract field info for this field, such as whether it is editable or required.
+        :param data_type_name: An optional override for the data type name used for this field. If not provided, then
+            the data field name of the FieldBuilder is used.
+        :param display_name: An optional override for the display name of this field. If not provided, then the data
+            field name doubles as the display name.
+        :return: An integer field definition with settings from the input criteria.
+        """
+        if abstract_info is None:
+            abstract_info = AnyFieldInfo()
+        if not data_type_name:
+            data_type_name = self.data_type
+        if not display_name:
+            display_name = field_name
+        return VeloxIntegerFieldDefinition(data_type_name, field_name, display_name, min_value, max_value,
+                                           default_value, unique_value, kwargs=abstract_info.__dict__)
+
+    def long_field(self, field_name: str, default_value: int | None = None, min_value: int = -2**63,
+                   max_value: int = 2**63 - 1, unique_value: bool = False, abstract_info: AnyFieldInfo | None = None, *,
+                   data_type_name: str | None = None, display_name: str | None = None) -> VeloxLongFieldDefinition:
+        """
+        Create a long field definition. Long fields are 64-bit whole numbers.
+
+        :param field_name: The data field name of this field. Unless a display name is also provided, this doubles as
+            the display name.
+        :param default_value: The default value to display in this field before the user edits it.
+        :param min_value: The minimum allowed value in this field.
+        :param max_value: The maximum allowed value in this field.
+        :param unique_value: Whether the value in this field must be unique across all temp records in the dialog.
+        :param abstract_info: The abstract field info for this field, such as whether it is editable or required.
+        :param data_type_name: An optional override for the data type name used for this field. If not provided, then
+            the data field name of the FieldBuilder is used.
+        :param display_name: An optional override for the display name of this field. If not provided, then the data
+            field name doubles as the display name.
+        :return: A long field definition with settings from the input criteria.
+        """
+        if abstract_info is None:
+            abstract_info = AnyFieldInfo()
+        if not data_type_name:
+            data_type_name = self.data_type
+        if not display_name:
+            display_name = field_name
+        return VeloxLongFieldDefinition(data_type_name, field_name, display_name, min_value, max_value, default_value,
+                                        unique_value, kwargs=abstract_info.__dict__)
+
+    def pick_list_field(self, field_name: str, pick_list_name: str, default_value: str | None = None,
+                        direct_edit: bool = False, abstract_info: AnyFieldInfo | None = None, *,
+                        data_type_name: str | None = None, display_name: str | None = None) -> VeloxPickListFieldDefinition:
+        """
+        Create a pick list field definition. Pick list fields are string fields that display a drop-down list of options
+        when being edited by a user. The list of options is backed by a pick list defined in the list manager sections
+        of the app setup.
+
+        Selection lists can do everything pick lists can do and more, so often it is better to use a selection list.
+
+        :param field_name: The data field name of this field. Unless a display name is also provided, this doubles as
+            the display name.
+        :param pick_list_name: The name of the pick list to populate the options of this field.
+        :param default_value: The default value to display in this field before the user edits it.
+        :param direct_edit: Whether the user may input values not present in the list of options.
+        :param abstract_info: The abstract field info for this field, such as whether it is editable or required.
+        :param data_type_name: An optional override for the data type name used for this field. If not provided, then
+            the data field name of the FieldBuilder is used.
+        :param display_name: An optional override for the display name of this field. If not provided, then the data
+            field name doubles as the display name.
+        :return: A pick list field definition with settings from the input criteria.
+        """
+        if abstract_info is None:
+            abstract_info = AnyFieldInfo()
+        if not data_type_name:
+            data_type_name = self.data_type
+        if not display_name:
+            display_name = field_name
+        return VeloxPickListFieldDefinition(data_type_name, field_name, display_name, pick_list_name, default_value,
+                                            direct_edit, kwargs=abstract_info.__dict__)
+
+    def selection_list_field(self, field_name: str, default_value: str | None = None, direct_edit: bool = False,
+                             multi_select: bool = False, unique_value: bool = False,
+                             abstract_info: AnyFieldInfo | None = None, *, pick_list_name: str | None = None,
+                             custom_report_name: str | None = None, plugin_name: str | None = None,
+                             static_values: list[str] | None = None, user_list: bool = False,
+                             user_group_list: bool = False, non_api_user_list: bool = False,
+                             data_type_name: str | None = None, display_name: str | None = None) \
+            -> VeloxSelectionFieldDefinition:
+        """
+        Create a selection list field definition. Selection list fields are string fields that display a drop-down list
+        of options when being edited by a user. The list of options can be populated from a number of locations,
+        including pick lists, predefined searches (custom reports), all usernames or groups in the system, and more.
+
+        Note that the different list types are mutually exclusive with one another. You must only provide the parameter
+        necessary for a singular selection list type.
+
+        :param field_name: The data field name of this field. Unless a display name is also provided, this doubles as
+            the display name.
+        :param default_value: The default value to display in this field before the user edits it.
+        :param direct_edit: Whether the user may input values not present in the list of options.
+        :param multi_select: Whether the user may select multiple options from the list of this field.
+        :param unique_value: Whether the value in this field must be unique across all temp records in the dialog.
+        :param pick_list_name: The name of the pick list to populate the options of this field.
+        :param custom_report_name: The name of the custom report (predefined search) to populate the options of this
+            field.
+        :param plugin_name: The path to the plugin used to populate the options of this field.
+        :param static_values: The list of string values used to populate the options of this field.
+        :param user_list: Whether this field is populated by a list of all users in the system.
+        :param user_group_list: Whether this field is populated by a list of all user groups in the system.
+        :param non_api_user_list: Whether this field is populated by a list of all non-API users in the system.
+        :param abstract_info: The abstract field info for this field, such as whether it is editable or required.
+        :param data_type_name: An optional override for the data type name used for this field. If not provided, then
+            the data field name of the FieldBuilder is used.
+        :param display_name: An optional override for the display name of this field. If not provided, then the data
+            field name doubles as the display name.
+        :return: A selection list field definition with settings from the input criteria.
+        """
+        if abstract_info is None:
+            abstract_info = AnyFieldInfo()
+        if not data_type_name:
+            data_type_name = self.data_type
+        if not display_name:
+            display_name = field_name
+
+        list_mode: ListMode | None = None
+        if pick_list_name:
+            list_mode = ListMode.LIST
+        if custom_report_name:
+            if list_mode:
+                raise SapioException("Unable to set multiple list modes at once for a selection list.")
+            list_mode = ListMode.REPORT
+        if plugin_name:
+            if list_mode:
+                raise SapioException("Unable to set multiple list modes at once for a selection list.")
+            list_mode = ListMode.PLUGIN
+        if user_list:
+            if list_mode:
+                raise SapioException("Unable to set multiple list modes at once for a selection list.")
+            list_mode = ListMode.USER
+        if user_group_list:
+            if list_mode:
+                raise SapioException("Unable to set multiple list modes at once for a selection list.")
+            list_mode = ListMode.USER_GROUP
+        if non_api_user_list:
+            if list_mode:
+                raise SapioException("Unable to set multiple list modes at once for a selection list.")
+            list_mode = ListMode.NON_API_USER
+        if static_values:
+            if list_mode:
+                raise SapioException("Unable to set multiple list modes at once for a selection list.")
+            # Static values don't have a list mode. Evaluate this last so that the multiple list modes check doesn't
+            # need to be more complex.
+
+        if not list_mode and static_values is None:
+            raise SapioException("A list mode must be chosen for selection list fields.")
+        return VeloxSelectionFieldDefinition(data_type_name, field_name, display_name,
+                                             list_mode, unique_value, multi_select,
+                                             default_value, pick_list_name, custom_report_name,
+                                             plugin_name, direct_edit, static_values,
+                                             kwargs=abstract_info.__dict__)
+
+    def short_field(self, field_name: str, default_value: int | None = None, min_value: int = -2**15,
+                    max_value: int = 2**15 - 1, unique_value: bool = False, abstract_info: AnyFieldInfo | None = None,
+                    *, data_type_name: str | None = None, display_name: str | None = None) -> VeloxShortFieldDefinition:
+        """
+        Create a short field definition. Short fields are 16-bit whole numbers.
+
+        :param field_name: The data field name of this field. Unless a display name is also provided, this doubles as
+            the display name.
+        :param default_value: The default value to display in this field before the user edits it.
+        :param min_value: The minimum allowed value in this field.
+        :param max_value: The maximum allowed value in this field.
+        :param unique_value: Whether the value in this field must be unique across all temp records in the dialog.
+        :param abstract_info: The abstract field info for this field, such as whether it is editable or required.
+        :param data_type_name: An optional override for the data type name used for this field. If not provided, then
+            the data field name of the FieldBuilder is used.
+        :param display_name: An optional override for the display name of this field. If not provided, then the data
+            field name doubles as the display name.
+        :return: A short field definition with settings from the input criteria.
+        """
+        if abstract_info is None:
+            abstract_info = AnyFieldInfo()
+        if not data_type_name:
+            data_type_name = self.data_type
+        if not display_name:
+            display_name = field_name
+        return VeloxShortFieldDefinition(data_type_name, field_name, display_name, min_value, max_value, default_value,
+                                         unique_value, kwargs=abstract_info.__dict__)
+
+    def string_field(self, field_name: str,
+                     default_value: str | None = None, max_length: int = 100, unique_value: bool = False,
+                     html_editor: bool = False, string_format: SapioStringFormat | None = None, num_lines: int = 1,
+                     auto_size: bool = False, link_out: dict[str, str] | None = None,
+                     field_validator: FieldValidator | None = None, abstract_info: AnyFieldInfo | None = None, *,
+                     data_type_name: str | None = None, display_name: str | None = None) -> VeloxStringFieldDefinition:
+        """
+        Create a string field definition. String fields represent text, and are highly customizable, allowing the
+        field to be plain text or rich HTML, take up one line of space or multiple on a form, format as emails or
+        phone numbers, or create links to other websites or other locations in the system.
+
+        :param field_name: The data field name of this field. Unless a display name is also provided, this doubles as
+            the display name.
+        :param default_value: The default value to display in this field before the user edits it.
+        :param max_length: The maximum allowed character length of this field.
+        :param unique_value: Whether the value in this field must be unique across all temp records in the dialog.
+        :param html_editor: Whether this field allows the user to use an HTML editor.
+        :param string_format: The format that this string field is displayed in. If no value is provided, the field
+            display as a normal string.
+        :param num_lines: The number of lines of space that this field takes up on a form.
+        :param auto_size: Whether this field should auto-size itself to fix the text when taking up space on a form.
+        :param link_out: A dictionary where the keys are the display names of the links and the values are the links to
+            navigate the user to if this field is clicked on. If the values contain the string "[[LINK_OUT]]" then that
+            macro will be replaced with the value of the string field when it is clicked. The display name is only
+            important if there is more than one link in the dictionary, in which case all available link out locations
+            will display in a dialog with their display names for the user to select. If a non-empty dictionary is
+            provided, this becomes a link-out field.
+            If the value is not determined to have the appearance of a URL (e.g. it doesn't start with https://), then
+            the system will prepend "https://<app-url>/veloxClient/" to the start of the URL. This allows you to create
+            links to other locations in the system without needing to know what the app URL is. For example, if you have
+            a link out string field that contains a record ID to a Sample, you could set the link value to
+            "#dataType=Sample;recordId=[[LINK_OUT]];view=dataRecord" and the client will, seeing that this is not a
+            normal looking URL, route the user to
+            https://<app-url>/veloxClient/#dataType=Sample;recordId=[[LINK_OUT]];view=dataRecord, which is the form
+            page of the Sample corresponding to the record ID recorded by the field value.
+        :param field_validator: If provided, the user's input for this field must pass the regex of the given validator.
+        :param abstract_info: The abstract field info for this field, such as whether it is editable or required.
+        :param data_type_name: An optional override for the data type name used for this field. If not provided, then
+            the data field name of the FieldBuilder is used.
+        :param display_name: An optional override for the display name of this field. If not provided, then the data
+            field name doubles as the display name.
+        :return: A string field definition with settings from the input criteria.
+        """
+        if abstract_info is None:
+            abstract_info = AnyFieldInfo()
+        if not data_type_name:
+            data_type_name = self.data_type
+        if not display_name:
+            display_name = field_name
+        link_out, link_out_url = self._convert_link_out(link_out)
+        return VeloxStringFieldDefinition(data_type_name, field_name, display_name, default_value, max_length,
+                                          unique_value, html_editor, string_format, num_lines, auto_size, link_out,
+                                          link_out_url, field_validator, kwargs=abstract_info.__dict__)
+
+    @staticmethod
+    def _convert_link_out(link_out: dict[str, str] | None) -> tuple[bool, str | None]:
+        """
+        Given a dictionary of link-out URLs, convert them to the string format that the field definition expects.
+        """
+        if link_out:
+            return True, "\t".join([display_name + "\t" + link for display_name, link in link_out.items()])
+        return False, None

sapiopycommons/chem/IndigoMolecules.py

@@ -9,6 +9,7 @@ indigo.setOption("ignore-stereochemistry-errors", True)
 indigo.setOption("render-stereo-style", "ext")
 indigo.setOption("aromaticity-model", "generic")
 indigo.setOption("render-coloring", True)
+indigo.setOption("molfile-saving-mode", "3000")
 indigo_inchi = IndigoInchi(indigo);
 
 

sapiopycommons/chem/Molecules.py

@@ -1,5 +1,6 @@
 # Author Yechen Qiao
 # Common Molecule Utilities for Molecule Transfers with Sapio
+from typing import cast
 
 from rdkit import Chem
 from rdkit.Chem import Crippen, MolToInchi
@@ -20,6 +21,25 @@ tautomer_params.tautomerReassignStereo = False
 tautomer_params.tautomerRemoveIsotopicHs = True
 enumerator = rdMolStandardize.TautomerEnumerator(tautomer_params)
 
+
+def get_enhanced_stereo_reg_hash(mol: Mol, enhanced_stereo: bool) -> str:
+    """
+    Get the Registration Hash for the molecule by the current registration configuration.
+    When we are running if we are canonicalization of tautomers or cleaning up any other way, do they first before calling.
+    :param mol: The molecule to obtain hash for.
+    :param canonical_tautomer: Whether the registry system canonicalize the tautomers.
+    :param enhanced_stereo: Whether we are computing enhanced stereo at all.
+    :return: The enhanced stereo hash.
+    """
+    if enhanced_stereo:
+        from rdkit.Chem.RegistrationHash import GetMolLayers, GetMolHash, HashScheme
+        layers = GetMolLayers(mol, enable_tautomer_hash_v2=True)
+        hash_scheme: HashScheme = HashScheme.TAUTOMER_INSENSITIVE_LAYERS
+        return GetMolHash(layers, hash_scheme=hash_scheme)
+    else:
+        return ""
+
+
 def neutralize_atoms(mol) -> Mol:
     """
     Neutralize atoms per https://baoilleach.blogspot.com/2019/12/no-charge-simple-approach-to.html
@@ -86,7 +106,6 @@ def mol_to_img(mol_str: str) -> str:
     return renderer.renderToString(mol)
 
 
-
 def mol_to_sapio_partial_pojo(mol: Mol):
     """
     Get the minimum information about molecule to Sapio, just its SMILES, V3000, and image data.
@@ -96,7 +115,7 @@ def mol_to_sapio_partial_pojo(mol: Mol):
     Chem.SanitizeMol(mol)
     mol.UpdatePropertyCache()
     smiles = Chem.MolToSmiles(mol)
-    molBlock = Chem.MolToMolBlock(mol)
+    molBlock = Chem.MolToMolBlock(mol, forceV3000=True)
     img = mol_to_img(mol)
     molecule = dict()
     molecule["smiles"] = smiles
@@ -105,23 +124,52 @@ def mol_to_sapio_partial_pojo(mol: Mol):
     return molecule
 
 
-def mol_to_sapio_substance(mol: Mol, include_stereoisomers: bool = False,
+def get_cxs_smiles_hash(mol: Mol, enhanced_stereo: bool) -> str:
+    """
+    Return the SHA1 CXS Smiles hash for the canonical, isomeric CXS SMILES of the molecule.
+    """
+    if not enhanced_stereo:
+        return ""
+    import hashlib
+    return hashlib.sha1(Chem.MolToCXSmiles(mol, canonical=True, isomericSmiles=True).encode()).hexdigest()
+
+
+def get_has_or_group(mol: Mol, enhanced_stereo: bool) -> bool:
+    """
+    Return true if and only if: enhanced stereochemistry is enabled and there is at least one OR group in mol.
+    """
+    if not enhanced_stereo:
+        return False
+    from rdkit.Chem import StereoGroup_vect, STEREO_OR
+    stereo_groups: StereoGroup_vect = mol.GetStereoGroups()
+    for stereo_group in stereo_groups:
+        if stereo_group.GetGroupType() == STEREO_OR:
+            return True
+    return False
+
+
+def mol_to_sapio_substance(mol: Mol, include_stereoisomers=False,
                            normalize: bool = False, remove_salt: bool = False, make_images: bool = False,
-                           salt_def: str | None = None, canonical_tautomer: bool = True):
+                           salt_def: str | None = None, canonical_tautomer: bool = True,
+                           enhanced_stereo: bool = False, remove_atom_map: bool = True):
     """
     Convert a molecule in RDKit to a molecule POJO in Sapio.
 
     :param mol: The molecule in RDKit.
-    :param include_stereoisomers: If true, will compute all stereoisomer permutations of this molecule.
     :param normalize If true, will normalize the functional groups and return normalized result.
     :param remove_salt If true, we will remove salts iteratively from the molecule before returning their data.
     We will also populate desaltedList with molecules we deleted.
+    :param make_images Whether to make images as part of the result without having another script to resolve it.
     :param salt_def: if not none, specifies custom salt to be used during the desalt process.
     :param canonical_tautomer: if True, we will attempt to compute canonical tautomer for the molecule. Slow!
     This is needed for a registry. Note it stops after enumeration of 1000.
+    :param enhanced_stereo: If enabled, enhanced stereo hash will be produced.
+    :param remove_atom_map: When set, clear all atom AAM maps that were set had it been merged into some reactions earlier.
     :return: The molecule POJO for Sapio.
     """
     molecule = dict()
+    if remove_atom_map:
+        [a.SetAtomMapNum(0) for a in mol.GetAtoms()]
     Chem.SanitizeMol(mol)
     mol.UpdatePropertyCache()
     Chem.GetSymmSSSR(mol)
@@ -157,7 +205,7 @@ def mol_to_sapio_substance(mol: Mol, include_stereoisomers: bool = False,
     exactMass = Descriptors.ExactMolWt(mol)
     molFormula = rdMolDescriptors.CalcMolFormula(mol)
     charge = Chem.GetFormalCharge(mol)
-    molBlock = Chem.MolToMolBlock(mol)
+    molBlock = Chem.MolToMolBlock(mol, forceV3000=True)
 
     molecule["cLogP"] = cLogP
     molecule["tpsa"] = tpsa
@@ -181,28 +229,38 @@ def mol_to_sapio_substance(mol: Mol, include_stereoisomers: bool = False,
     # We need to test the INCHI can be loaded back to indigo.
     indigo_mol = indigo.loadMolecule(molBlock)
     indigo_mol.aromatize()
-    indigo_inchi.resetOptions()
-    indigo_inchi_str = indigo_inchi.getInchi(indigo_mol)
-    molecule["inchi"] = indigo_inchi_str
-    indigo_inchi_key_str = indigo_inchi.getInchiKey(indigo_inchi_str)
-    molecule["inchiKey"] = indigo_inchi_key_str
+    if enhanced_stereo:
+        # Remove enhanced stereo layer when generating InChI as the stereo hash is generated separately for reg.
+        mol_copy: Mol = Chem.Mol(mol)
+        Chem.CanonicalizeEnhancedStereo(mol_copy)
+        molecule["inchi"] = Chem.MolToInchi(mol_copy)
+        molecule["inchiKey"] = Chem.MolToInchiKey(mol_copy)
+    else:
+        indigo_inchi.resetOptions()
+        indigo_inchi_str = indigo_inchi.getInchi(indigo_mol)
+        molecule["inchi"] = indigo_inchi_str
+        indigo_inchi_key_str = indigo_inchi.getInchiKey(indigo_inchi_str)
+        molecule["inchiKey"] = indigo_inchi_key_str
     molecule["smiles"] = indigo_mol.smiles()
+    molecule["reg_hash"] = get_enhanced_stereo_reg_hash(mol, enhanced_stereo=enhanced_stereo)
+    molecule["cxsmiles_hash"] = get_cxs_smiles_hash(mol, enhanced_stereo=enhanced_stereo)
+    molecule["has_or_group"] = get_has_or_group(mol, enhanced_stereo=enhanced_stereo)
 
-    if include_stereoisomers and has_chiral_centers(mol):
-        stereoisomers = find_all_possible_stereoisomers(mol, only_unassigned=False, try_embedding=False, unique=True)
-        molecule["stereoisomers"] = [mol_to_sapio_partial_pojo(x) for x in stereoisomers]
     return molecule
 
 
-def mol_to_sapio_compound(mol: Mol, include_stereoisomers: bool = False,
+def mol_to_sapio_compound(mol: Mol, include_stereoisomers=False, enhanced_stereo: bool = False,
                           salt_def: str | None = None, resolve_canonical: bool = True,
-                          make_images: bool = False, canonical_tautomer: bool = True):
+                          make_images: bool = False, canonical_tautomer: bool = True,
+                          remove_atom_map: bool = True):
     ret = dict()
-    ret['originalMol'] = mol_to_sapio_substance(mol, include_stereoisomers,
+    ret['originalMol'] = mol_to_sapio_substance(mol, include_stereoisomers=False,
                                                 normalize=False, remove_salt=False, make_images=make_images,
-                                                canonical_tautomer=canonical_tautomer)
+                                                canonical_tautomer=canonical_tautomer,
+                                                enhanced_stereo=enhanced_stereo, remove_atom_map=remove_atom_map)
     if resolve_canonical:
         ret['canonicalMol'] = mol_to_sapio_substance(mol, include_stereoisomers=False,
                                                      normalize=True, remove_salt=True, make_images=make_images,
-                                                     salt_def=salt_def, canonical_tautomer=canonical_tautomer)
+                                                     salt_def=salt_def, canonical_tautomer=canonical_tautomer,
+                                                     enhanced_stereo=enhanced_stereo, remove_atom_map=remove_atom_map)
     return ret

sapiopycommons/eln/experiment_report_util.py

@@ -427,7 +427,7 @@ class ExperimentReportUtil:
         return ret_val
 
     @staticmethod
-    def get_experiments_by_creator(context: UserIdentifier, created_by: str, *,
+    def get_experiments_by_creator(context: UserIdentifier, created_by: str,
                                    criteria: ExperimentReportCriteria = ExperimentReportCriteria()) \
             -> list[ElnExperiment]:
         """
@@ -442,7 +442,7 @@ class ExperimentReportUtil:
         return ExperimentReportUtil.get_experiments_by_creators(context, [created_by], criteria=criteria)[created_by]
 
     @staticmethod
-    def get_experiments_by_creators(context: UserIdentifier, created_by: list[str], *,
+    def get_experiments_by_creators(context: UserIdentifier, created_by: list[str],
                                     criteria: ExperimentReportCriteria = ExperimentReportCriteria()) \
             -> dict[str, list[ElnExperiment]]:
         """

sapiopycommons/flowcyto/flow_cyto.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from weakref import WeakValueDictionary
+
+from sapiopylib.rest.User import SapioUser
+from databind.json import dumps
+
+from sapiopycommons.flowcyto.flowcyto_data import FlowJoWorkspaceInputJson, UploadFCSInputJson, \
+    ComputeFlowStatisticsInputJson
+
+
+class FlowCytoManager:
+    """
+    This manager includes flow cytometry analysis tools that would require FlowCyto license to use.
+    """
+    _user: SapioUser
+
+    __instances: WeakValueDictionary[SapioUser, FlowCytoManager] = WeakValueDictionary()
+    __initialized: bool
+
+    def __new__(cls, user: SapioUser):
+        """
+        Observes singleton pattern per record model manager object.
+
+        :param user: The user that will make the webservice request to the application.
+        """
+        obj = cls.__instances.get(user)
+        if not obj:
+            obj = object.__new__(cls)
+            obj.__initialized = False
+            cls.__instances[user] = obj
+        return obj
+
+    def __init__(self, user: SapioUser):
+        if self.__initialized:
+            return
+        self._user = user
+        self.__initialized = True
+
+    def create_flowjo_workspace(self, workspace_input: FlowJoWorkspaceInputJson) -> int:
+        """
+        Create FlowJo Workspace and return the workspace record ID of workspace root record,
+        after successful creation.
+        :param workspace_input: the request data payload.
+        :return: The new workspace record ID.
+        """
+        payload = dumps(workspace_input, FlowJoWorkspaceInputJson)
+        response = self._user.plugin_post("flowcyto/workspace", payload=payload, is_payload_plain_text=True)
+        self._user.raise_for_status(response)
+        return int(response.json())
+
+    def upload_fcs_for_sample(self, upload_input: UploadFCSInputJson) -> int:
+        """
+        Upload FCS file as root of the sample FCS.
+        :param upload_input: The request data payload
+        :return: The root FCS file uploaded under sample.
+        """
+        payload = dumps(upload_input, UploadFCSInputJson)
+        response = self._user.plugin_post("flowcyto/fcs", payload=payload, is_payload_plain_text=True)
+        self._user.raise_for_status(response)
+        return int(response.json())
+
+    def compute_statistics(self, stat_compute_input: ComputeFlowStatisticsInputJson) -> list[int]:
+        """
+        Requests to compute flow cytometry statistics.
+        The children are of type FCSStatistic.
+        If the FCS files have not been evaluated yet,
+        then the lazy evaluation will be performed immediately prior to computing statistics, which can take longer.
+        If any new statistics are computed as children of FCS, they will be returned in the result record id list.
+        Note: if input has multiple FCS files, the client should try to get parent FCS file from each record to figure out which one is for which FCS.
+        :param stat_compute_input:
+        :return:
+        """
+        payload = dumps(stat_compute_input, ComputeFlowStatisticsInputJson)
+        response = self._user.plugin_post("flowcyto/statistics", payload=payload, is_payload_plain_text=True)
+        self._user.raise_for_status(response)
+        return list(response.json())

sapiopycommons/flowcyto/flowcyto_data.py

@@ -0,0 +1,75 @@
+import base64
+from enum import Enum
+
+from databind.core.dataclasses import dataclass
+
+
+class ChannelStatisticType(Enum):
+    """
+    All supported channel statistics type.
+    """
+    MEAN = "(Mean) MFI"
+    MEDIAN = "(Median) MFI"
+    STD_EV = "Std. Dev."
+    COEFFICIENT_OF_VARIATION = "CV"
+
+    display_name: str
+
+    def __init__(self, display_name: str):
+        self.display_name = display_name
+
+
+@dataclass
+class ChannelStatisticsParameterJSON:
+    channelNameList: list[str]
+    statisticsType: ChannelStatisticType
+
+    def __init__(self, channel_name_list: list[str], stat_type: ChannelStatisticType):
+        self.channelNameList = channel_name_list
+        self.statisticsType = stat_type
+
+
+@dataclass
+class ComputeFlowStatisticsInputJson:
+    fcsFileRecordIdList: list[int]
+    statisticsParameterList: list[ChannelStatisticsParameterJSON]
+
+    def __init__(self, fcs_file_record_id_list: list[int], statistics_parameter_list: list[ChannelStatisticsParameterJSON]):
+        self.fcsFileRecordIdList = fcs_file_record_id_list
+        self.statisticsParameterList = statistics_parameter_list
+
+
+@dataclass
+class FlowJoWorkspaceInputJson:
+    filePath: str
+    base64Data: str
+
+    def __init__(self, filePath: str, file_data: bytes):
+        self.filePath = filePath
+        self.base64Data = base64.b64encode(file_data).decode('utf-8')
+
+
+@dataclass
+class UploadFCSInputJson:
+    """
+    Request to upload new FCS file
+    Attributes:
+        filePath: The file name of the FCS file to be uploaded. For FlowJo workspace, this is important to match the file in group (via file names).
+        attachmentDataType: the attachment data type that contains already-uploaded FCS data.
+        attachmentRecordId: the attachment record ID that contains already-uploaded FCS data.
+        associatedRecordDataType: the "parent" association for the FCS. Can either be a workspace or a sample record.
+        associatedRecordId: the "parent" association for the FCS. Can either be a workspace or a sample record.
+    """
+    filePath: str
+    attachmentDataType: str
+    attachmentRecordId: int
+    associatedRecordDataType: str
+    associatedRecordId: int
+
+    def __init__(self, associated_record_data_type: str, associated_record_id: int,
+                 file_path: str, attachment_data_type: str, attachment_record_id: int):
+        self.filePath = file_path
+        self.attachmentDataType = attachment_data_type
+        self.attachmentRecordId = attachment_record_id
+        self.associatedRecordDataType = associated_record_data_type
+        self.associatedRecordId = associated_record_id

sapiopycommons/multimodal/multimodal_data.py

@@ -38,6 +38,9 @@ class PyMolecule:
     normError: str | None
     desaltError: str | None
     desaltedList: list[str] | None
+    registrationHash: str | None
+    hasOrGroup: bool
+    CXSMILESHash: str | None
 
 
 @dataclass
@@ -100,9 +103,9 @@ class PyMoleculeLoaderResult:
         compoundList: the compounds successfully loaded.
         errorList: an error record is added here for each one we failed to load in Sapio.
     """
-    compoundByStr: dict[str, PyCompound]
-    compoundList: list[PyCompound]
-    errorList: list[ChemLoadingError]
+    compoundByStr: dict[str, PyCompound] | None
+    compoundList: list[PyCompound] | None
+    errorList: list[ChemLoadingError] | None
 
 
 @dataclass

{sapiopycommons-2024.10.29a346.dist-info → sapiopycommons-2024.10.30a348.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2024.10.29a346
+Version: 2024.10.30a348
 Summary: Official Sapio Python API Utilities Package
 Project-URL: Homepage, https://github.com/sapiosciences
 Author-email: Jonathan Steck <jsteck@sapiosciences.com>, Yechen Qiao <yqiao@sapiosciences.com>

{sapiopycommons-2024.10.29a346.dist-info → sapiopycommons-2024.10.30a348.dist-info}/RECORD

@@ -1,8 +1,9 @@
 sapiopycommons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/callbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/callbacks/callback_util.py,sha256=nb6cXK8yFq96gtG0Z2NiK-qdNaRh88bavUH-ZoBjh18,67953
-sapiopycommons/chem/IndigoMolecules.py,sha256=QqFDi9CKERj6sn_ZwVcS2xZq4imlkaTeCrpq1iNcEJA,1992
-sapiopycommons/chem/Molecules.py,sha256=t80IsQBPJ9mwE8ZxnWomAGrZDhdsOuPvLaTPb_N6jGU,8639
+sapiopycommons/callbacks/field_builder.py,sha256=8n0jcbMgtMUHjie4C1-IkpAuHz4zBxbZtWpr4y0kABU,36868
+sapiopycommons/chem/IndigoMolecules.py,sha256=3f-aig3AJkKJhRmhlQ0cI-5G8oeaQk_3foJTDZCvoko,2040
+sapiopycommons/chem/Molecules.py,sha256=SQKnqdZnhYj_6HGtEZmE_1DormonRR1-nBAQ__z4gms,11485
 sapiopycommons/chem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/customreport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/customreport/column_builder.py,sha256=0RO53e9rKPZ07C--KcepN6_tpRw_FxF3O9vdG0ilKG8,3014
@@ -14,7 +15,7 @@ sapiopycommons/datatype/data_fields.py,sha256=g8Ib6LH8ikNu9AzeVJs8Z2qS8A-cplACeF
 sapiopycommons/datatype/pseudo_data_types.py,sha256=Fe75Rnq5evyeJM1nC0sLkLGKAC74g2-GEeTdMeId80o,27649
 sapiopycommons/eln/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/eln/experiment_handler.py,sha256=VJPBQSP_4QmhSGDCRDOb5neOjGM6sZ9krvJEmDkpVV8,69282
-sapiopycommons/eln/experiment_report_util.py,sha256=MmRQIS3oURnnFJ9tFue7yS-_0gtajNUr7PeShPqmSHY,37685
+sapiopycommons/eln/experiment_report_util.py,sha256=9wWV6oEdKtfn2rI5V0BtmuW9OJlGFd9U07FIf889Gjw,37679
 sapiopycommons/eln/plate_designer.py,sha256=FYJfhhNq8hdfuXgDYOYHy6g0m2zNwQXZWF_MTPzElDg,7184
 sapiopycommons/files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/files/complex_data_loader.py,sha256=T39veNhvYl6j_uZjIIJ8Mk5Aa7otR5RB-g8XlAdkksA,1421
@@ -24,6 +25,8 @@ sapiopycommons/files/file_data_handler.py,sha256=SCsjODMJIPEBSsahzXUeOM7CfSCmYwP
 sapiopycommons/files/file_util.py,sha256=wbL3rxcFc-t2mXaPWWkoFWYGopvTcQts9Wf-L5GkhT8,29498
 sapiopycommons/files/file_validator.py,sha256=4OvY98ueJWPJdpndwnKv2nqVvLP9S2W7Il_dM0Y0ojo,28709
 sapiopycommons/files/file_writer.py,sha256=96Xl8TTT46Krxe_J8rmmlEMtel4nzZB961f5Yqtl1-I,17616
+sapiopycommons/flowcyto/flow_cyto.py,sha256=YlkKJR_zEHYRuNW0bnTqlTyZeXs0lOaeSCfG2fnfD7E,3227
+sapiopycommons/flowcyto/flowcyto_data.py,sha256=mYKFuLbtpJ-EsQxLGtu4tNHVlygTxKixgJxJqD68F58,2596
 sapiopycommons/general/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/general/accession_service.py,sha256=HYgyOsH_UaoRnoury-c2yTW8SeG4OtjLemdpCzoV4R8,13484
 sapiopycommons/general/aliases.py,sha256=tdDBNWSGx6s39eHJ3n2kscc4xxW3ZYaUfDftct6FmJE,12910
@@ -35,7 +38,7 @@ sapiopycommons/general/sapio_links.py,sha256=o9Z-8y2rz6AI0Cy6tq58ElPge9RBnisGc9N
 sapiopycommons/general/storage_util.py,sha256=ovmK_jN7v09BoX07XxwShpBUC5WYQOM7dbKV_VeLXJU,8892
 sapiopycommons/general/time_util.py,sha256=jUAWmQLNcLHZa4UYB4ht_I3d6uoi63VxYdo7T80Ydw0,7458
 sapiopycommons/multimodal/multimodal.py,sha256=A1QsC8QTPmgZyPr7KtMbPRedn2Ie4WIErodUvQ9otgU,6724
-sapiopycommons/multimodal/multimodal_data.py,sha256=p_caXW0vrURkzDHHspUptEI7lVFpZUrmyF7foz2fAvA,14983
+sapiopycommons/multimodal/multimodal_data.py,sha256=t-0uY4cVgm88uXaSOL4ZeB6zmdHufowXuLFlMk61wFg,15087
 sapiopycommons/processtracking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/processtracking/custom_workflow_handler.py,sha256=0Si5RQ1YFmqmcZWV8jNDKTffix2iZnQJ6b97fn31pbc,23859
 sapiopycommons/processtracking/endpoints.py,sha256=w5bziI2xC7450M95rCF8JpRwkoni1kEDibyAux9B12Q,10848
@@ -50,7 +53,7 @@ sapiopycommons/webhook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 sapiopycommons/webhook/webhook_context.py,sha256=D793uLsb1691SalaPnBUk3rOSxn_hYLhdvkaIxjNXss,1909
 sapiopycommons/webhook/webhook_handlers.py,sha256=JTquLBln49L1pJ9txJ4oc4Hpzy9kYtMKs0m4SLaFx78,18363
 sapiopycommons/webhook/webservice_handlers.py,sha256=1J56zFI0pWl5MHoNTznvcZumITXgAHJMluj8-2BqYEw,3315
-sapiopycommons-2024.10.29a346.dist-info/METADATA,sha256=uuwRweqff1sOl8f3xxmdruTfvovfEHNSsjc17It7Uhw,3177
-sapiopycommons-2024.10.29a346.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-sapiopycommons-2024.10.29a346.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
-sapiopycommons-2024.10.29a346.dist-info/RECORD,,
+sapiopycommons-2024.10.30a348.dist-info/METADATA,sha256=U8UVQE9LmFPyIDkAZka9MQcyFTd7QGBqH7TSlyx2MKE,3177
+sapiopycommons-2024.10.30a348.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+sapiopycommons-2024.10.30a348.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+sapiopycommons-2024.10.30a348.dist-info/RECORD,,