sapiopycommons 2024.6.29a275__tar.gz → 2024.7.2a279__tar.gz

{sapiopycommons-2024.6.29a275 → sapiopycommons-2024.7.2a279}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2024.6.29a275
+Version: 2024.7.2a279
 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.6.29a275 → sapiopycommons-2024.7.2a279}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sapiopycommons"
-version='2024.06.29a275'
+version='2024.07.02a279'
 authors = [
     { name="Jonathan Steck", email="jsteck@sapiosciences.com" },
     { name="Yechen Qiao", email="yqiao@sapiosciences.com" },

sapiopycommons-2024.7.2a279/src/sapiopycommons/general/accession_service.py

@@ -0,0 +1,375 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+from weakref import WeakValueDictionary
+
+from sapiopylib.rest.User import SapioUser
+
+_STR_JAVA_TYPE = "java.lang.String"
+_INT_JAVA_TYPE = "java.lang.Integer"
+_BOOL_JAVA_TYPE = "java.lang.Boolean"
+
+
+class AbstractAccessionServiceOperator(ABC):
+    """
+    Abstract class to define an accession service operator.
+    The default one in sapiopycommon only includes the out of box operators.
+    More can be added via java plugins for global operators.
+    """
+
+    @property
+    @abstractmethod
+    def op_class_name(self) -> str:
+        pass
+
+    @property
+    @abstractmethod
+    def op_param_value_list(self) -> list[Any] | None:
+        pass
+
+    @property
+    @abstractmethod
+    def op_param_class_name_list(self) -> list[str] | None:
+        pass
+
+    @property
+    @abstractmethod
+    def default_accessor_name(self) -> str:
+        pass
+
+
+class AccessionWithPrefixSuffix(AbstractAccessionServiceOperator):
+    """
+    Local operator for accessioning prefix and suffix format.
+    """
+    _prefix: str | None
+    _suffix: str | None
+    _num_of_digits: int | None
+    _start_num: int
+    _strict_mode: bool
+
+    @property
+    def prefix(self):
+        return self._prefix
+
+    @property
+    def suffix(self):
+        return self._suffix
+
+    @property
+    def num_of_digits(self):
+        return self._num_of_digits
+
+    @property
+    def start_num(self):
+        return self._start_num
+
+    @property
+    def strict_mode(self):
+        return self._strict_mode
+
+    def __init__(self, prefix: str | None, suffix: str | None, num_of_digits: int | None = None,
+                 start_num: int = 1, strict_mode: bool = False):
+        if prefix is None:
+            prefix = ""
+        if suffix is None:
+            suffix = ""
+        self._prefix = prefix
+        self._suffix = suffix
+        self._num_of_digits = num_of_digits
+        self._start_num = start_num
+        self._strict_mode = strict_mode
+
+    @property
+    def op_param_value_list(self):
+        return [self._prefix, self._suffix, self._num_of_digits, self._start_num, self._strict_mode]
+
+    @property
+    def op_param_class_name_list(self):
+        return [_STR_JAVA_TYPE, _STR_JAVA_TYPE, _INT_JAVA_TYPE, _INT_JAVA_TYPE, _BOOL_JAVA_TYPE]
+
+    @property
+    def op_class_name(self):
+        return "com.velox.accessionservice.operators.AccessionWithPrefixSuffix"
+
+    @property
+    def default_accessor_name(self):
+        return "PREFIX_AND_SUFFIX" + "(" + self.prefix + "," + self.suffix + ")";
+
+
+class AccessionGlobalPrefixSuffix(AbstractAccessionServiceOperator):
+    """
+    Global operator for accessioning prefix and suffix format.
+    """
+    _prefix: str | None
+    _suffix: str | None
+    _num_of_digits: int | None
+    _start_num: int
+    _strict_mode: bool
+
+    @property
+    def prefix(self):
+        return self._prefix
+
+    @property
+    def suffix(self):
+        return self._suffix
+
+    @property
+    def num_of_digits(self):
+        return self._num_of_digits
+
+    @property
+    def start_num(self):
+        return self._start_num
+
+    @property
+    def strict_mode(self):
+        return self._strict_mode
+
+    def __init__(self, prefix: str | None, suffix: str | None, num_of_digits: int | None = None,
+                 start_num: int = 1, strict_mode: bool = False):
+        if prefix is None:
+            prefix = ""
+        if suffix is None:
+            suffix = ""
+        self._prefix = prefix
+        self._suffix = suffix
+        self._num_of_digits = num_of_digits
+        self._start_num = start_num
+        self._strict_mode = strict_mode
+
+    @property
+    def op_param_value_list(self):
+        return [self._prefix, self._suffix, self._num_of_digits, self._start_num, self._strict_mode]
+
+    @property
+    def op_param_class_name_list(self):
+        return [_STR_JAVA_TYPE, _STR_JAVA_TYPE, _INT_JAVA_TYPE, _INT_JAVA_TYPE, _BOOL_JAVA_TYPE]
+
+    @property
+    def op_class_name(self):
+        return "com.velox.accessionservice.operators.sapio.AccessionGlobalPrefixSuffix"
+
+    @property
+    def default_accessor_name(self):
+        return "PREFIX_AND_SUFFIX" + "(" + self._prefix + "," + self._suffix + ")"
+
+
+class AccessionNextBarcode(AbstractAccessionServiceOperator):
+    """
+    From Java description:
+    This will start accessioning at the getNextBarcode() when there's no system preference to be backward compatible.
+    However, once it completes setting the first ID, it will start increment by its own preference and disregards getNextBarcode().
+
+    Recommend using AccessionServiceBasicManager to accession next barcode.
+    To avoid ambiguity in preference cache.
+
+    This should not be used unless we are using something legacy such as plate mapping template record creation
+    (Note: not 3D plating, I'm talking about the older aliquoter).
+    """
+
+    @property
+    def op_param_value_list(self):
+        return []
+
+    @property
+    def op_param_class_name_list(self):
+        return []
+
+    @property
+    def op_class_name(self):
+        return "com.velox.accessionservice.operators.sapio.AccessionNextBarcode"
+
+    @property
+    def default_accessor_name(self):
+        return "Barcode"
+
+
+class AccessionRequestId(AbstractAccessionServiceOperator):
+    """
+    This class implements the accessioning operator for com.velox.sapioutils.shared.managers.DataRecordUtilManager.getNextRequestId()
+    and getNextRequestId(int numberOfCharacters).
+
+    Operation: For 4 characters start with A001, increment by 1 until A999. Then We use B001.
+    After Z999 we start with AA01 until we get to AA99, etc.
+
+    Exception: Skips I and O to prevent confusions with 1 and 0 when incrementing letters.
+
+    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.
+    """
+    _num_of_characters: int
+    _accessor_name: str
+
+    @property
+    def num_of_characters(self):
+        return self._num_of_characters
+
+    @property
+    def accessor_name(self):
+        return self._accessor_name
+
+    def __init__(self, num_of_characters: int = 4, accessor_name: str = None):
+        self._num_of_characters = num_of_characters
+        if not accessor_name:
+            accessor_name = self.default_accessor_name
+        self._accessor_name = accessor_name
+
+    @property
+    def op_class_name(self):
+        return "com.velox.accessionservice.operators.sapio.AccessionRequestId"
+
+    @property
+    def op_param_value_list(self):
+        return [self._num_of_characters, self._accessor_name]
+
+    @property
+    def op_param_class_name_list(self):
+        return [_INT_JAVA_TYPE, _STR_JAVA_TYPE]
+
+    @property
+    def default_accessor_name(self):
+        return "SapioNextRequestIdMap"
+
+
+class AccessionServiceDescriptor:
+    """
+    Describes a single accession service's accessioning request
+
+    Attributes:
+        opClassName: The accession service operator class name as in Java
+        opParamValueList: Ordered list of parameter values to construct the accession service operator.
+        opParamClassNameList: Ordered list of FQCN of java classes in order of parameter value list.
+        dataTypeName: The data type to accession. Should be blank if opClassName resolves to a global operator.
+        dataFieldName: The data field to accession. Should be blank if opClassName resolves to a global operator.
+        accessorName: The accessor cache name to be used for accessioning.
+        numIds: The number of IDs to accession.
+    """
+    op: AbstractAccessionServiceOperator
+    dataTypeName: str | None
+    dataFieldName: str | None
+    accessorName: str
+    numIds: int
+
+    def __init__(self, accessor_name: str, op: AbstractAccessionServiceOperator, num_ids: int,
+                 data_type_name: str | None, data_field_name: str | None):
+        self.accessorName = accessor_name
+        self.op = op
+        self.dataTypeName = data_type_name
+        self.dataFieldName = data_field_name
+        self.numIds = num_ids
+
+    def to_json(self):
+        return {
+            "opClassName": self.op.op_class_name,
+            "opParamValueList": self.op.op_param_value_list,
+            "opParamClassNameList": self.op.op_param_class_name_list,
+            "accessorName": self.accessorName,
+            "numIds": self.numIds,
+            "dataTypeName": self.dataTypeName,
+            "dataFieldName": self.dataFieldName
+        }
+
+
+class AccessionService:
+    """
+    Provides Sapio Foundations Accession Service functionalities.
+    """
+    _user: SapioUser
+
+    __instances: WeakValueDictionary[SapioUser, AccessionService] = WeakValueDictionary()
+    __initialized: bool
+
+    @property
+    def user(self) -> SapioUser:
+        return self._user
+
+    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 accession_with_config(self, data_type_name: str, data_field_name: str, num_ids: int) -> list[str]:
+        """
+        Accession with Configuration Manager => Accession Service configuration (This is not visible to regular users in SaaS)
+        """
+        payload = {
+            "dataTypeName": data_type_name,
+            "dataFieldName": data_field_name,
+            "numIds": num_ids
+        }
+        response = self.user.plugin_post("accessionservice/accession_with_config", payload=payload)
+        self.user.raise_for_status(response)
+        return list(response.json())
+
+    def accession_in_batch(self, descriptor: AccessionServiceDescriptor) -> list[str]:
+        """
+        This is the most flexible way to make use of accession service: directly via a descriptor object.
+        """
+        payload = descriptor.to_json()
+        response = self.user.plugin_post("accessionservice/accession", payload=payload)
+        self.user.raise_for_status(response)
+        return list(response.json())
+
+    def accession_next_request_id_list(self, num_of_characters: int, num_ids: int) -> list[str]:
+        """
+        Accession Request ID by old LIMS format. This is usually deprecated today.
+        :param num_of_characters: Number of characters minimum in request ID.
+        :param num_ids: Number of request IDs to accession.
+        """
+        op = AccessionRequestId(num_of_characters)
+        descriptor = AccessionServiceDescriptor(op.default_accessor_name, op, num_ids, None, None)
+        return self.accession_in_batch(descriptor)
+
+    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.
+        :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.
+        :param prefix: leave it empty string "" if no prefix. Otherwise, specifies the prefix of ID.
+        :param suffix: leave it empty string "" if no suffix. Otherwise, specifies the suffix of ID.
+        :param num_digits: None if unlimited with no leading zeros.
+        :param start_num The number to begin accessioning if this is the first time.
+        :return:
+        """
+        op = AccessionWithPrefixSuffix(prefix, suffix, num_digits, start_num)
+        descriptor = AccessionServiceDescriptor(op.default_accessor_name, op, num_ids, data_type_name, data_field_name)
+        return self.accession_in_batch(descriptor)
+
+    def get_global_affixed_id_in_batch(
+            self, num_ids: int, prefix: str | None, suffix: str | None, num_digits: int | None, start_num: int = 1) -> list[str]:
+        """
+        Get the next numOfIds affixed IDs using system preference cache that's maximum across all datatype and datafields and maximal for the format.
+        This method allows users to customize a start number instead of always starting at 1.
+        :param num_ids: The number of IDs to accession.
+        :param prefix: leave it empty string "" if no prefix. Otherwise, specifies the prefix of ID.
+        :param suffix: leave it empty string "" if no suffix. Otherwise, specifies the suffix of ID.
+        :param num_digits: None if unlimited with no leading zeros.
+        :param start_num The number to begin accessioning if this is the first time.
+        """
+        op: AbstractAccessionServiceOperator
+        if not prefix and not suffix:
+            op = AccessionNextBarcode()
+        else:
+            op = AccessionGlobalPrefixSuffix(prefix, suffix, num_digits, start_num)
+        descriptor = AccessionServiceDescriptor(op.default_accessor_name, op, num_ids, None, None)
+        return self.accession_in_batch(descriptor)

{sapiopycommons-2024.6.29a275 → sapiopycommons-2024.7.2a279}/src/sapiopycommons/multimodal/multimodal.py

@@ -1,11 +1,13 @@
 # Multimodal registration client
 from __future__ import annotations
 
+import io
 from weakref import WeakValueDictionary
 
 from databind.json import dumps, loads
 from sapiopylib.rest.User import SapioUser
 
+from sapiopycommons.general.exceptions import SapioException
 from sapiopycommons.multimodal.multimodal_data import *
 
 
@@ -103,7 +105,7 @@ class MultiModalManager:
         self._user.raise_for_status(response)
         return loads(response.text, ChemSearchResponsePojo)
 
-    def run_multi_sequence_alignment(self, request: MultiSequenceAlignmentRequestPojo):
+    def run_multi_sequence_alignment(self, request: MultiSequenceAlignmentRequestPojo) -> list[MultiSequenceAlignmentSeqPojo]:
         """
         Run a multi-sequence alignment using the specified tool and strategy.
         :param request: The request object containing the sequences and alignment parameters. The parameters inside it can be the pojo dict of one of the options.
@@ -115,7 +117,7 @@ class MultiModalManager:
         self._user.raise_for_status(response)
         return loads(response.text, list[MultiSequenceAlignmentSeqPojo])
 
-    def register_bio(self, request: BioFileRegistrationRequest):
+    def register_bio(self, request: BioFileRegistrationRequest) -> BioFileRegistrationResponse:
         """
         Register to bioregistry of a file.
         """
@@ -124,3 +126,21 @@ class MultiModalManager:
         self._user.raise_for_status(response)
         return loads(response.text, BioFileRegistrationResponse)
 
+    def export_to_sdf(self, request: ChemExportSDFRequest) -> str:
+        """
+        Export the SDF files
+        :param request: The request for exporting SDF file.
+        :return: the SDF plain text data.
+        """
+        payload = dumps(request, ChemExportSDFRequest)
+        response = self._user.plugin_post("chemistry/export_sdf", payload=payload, is_payload_plain_text=True)
+        self._user.raise_for_status(response)
+        gzip_base64: str = response.text
+        if not gzip_base64:
+            raise SapioException("Returning data from server is blank for export SDF.")
+        decoded_bytes = base64.b64decode(gzip_base64)
+        with io.BytesIO(decoded_bytes) as bytes_io:
+            import gzip
+            with gzip.GzipFile(fileobj=bytes_io, mode='rb') as f:
+                ret: str = f.read().decode()
+                return ret

{sapiopycommons-2024.6.29a275 → sapiopycommons-2024.7.2a279}/src/sapiopycommons/multimodal/multimodal_data.py

@@ -462,3 +462,26 @@ class BioFileRegistrationResponse:
     newRecordIdList: list[int]
     oldRecordIdList: list[int]
 
+
+@dataclass
+class ChemExportSDFRequest:
+    """
+    A request to export SDF data from Sapio to Python REST client.
+    """
+    partDataTypeName: str
+    partRecordIdList: list[int]
+
+    forceV3000: bool
+    fieldNameList: list[str] | None
+    assayNameList: list[str] | None
+    additionalPropertiesByRecordId: dict[int, dict[str, Any]] | None
+
+    def __init__(self, partDataTypeName: str, partRecordIdList: list[int], forceV3000: bool = True,
+                 fieldNameList: list[str] | None = None, assayNameList: list[str] | None = None,
+                 additionalPropertiesByRecordId: dict[int, dict[str, Any]] | None = None):
+        self.partDataTypeName = partDataTypeName
+        self.partRecordIdList = partRecordIdList
+        self.forceV3000 = forceV3000
+        self.fieldNameList = fieldNameList
+        self.assayNameList = assayNameList
+        self.additionalPropertiesByRecordId = additionalPropertiesByRecordId

sapiopycommons-2024.7.2a279/tests/accession_test.py

@@ -0,0 +1,41 @@
+import unittest
+
+from sapiopylib.rest.User import SapioUser
+
+from sapiopycommons.general.accession_service import AccessionService
+from data_type_models import SampleModel
+
+user = SapioUser(url="https://linux-vm:8443/webservice/api", verify_ssl_cert=False,
+                 guid="3c232543-f407-4828-aae5-b33d4cd31fa7",
+                 username="yqiao_api", password="Password1!")
+
+accession_service = AccessionService(user)
+
+# This test needs to be run together with accessioning happening separately inside Sapio for creating samples/plates in 3D plater.
+# Set plate to auto accession mode and ensure plate ID is non-unique to trigger global accessioning logic.
+class AccessionServiceTest(unittest.TestCase):
+
+    def test_sample_accession_with_config(self):
+        """
+        This is how platform accessions new samples that isn't an aliquot or pool.
+        """
+        id_list = accession_service.accession_with_config(SampleModel.DATA_TYPE_NAME, SampleModel.SAMPLEID__FIELD_NAME.field_name, 5)
+        print("New Sample IDs: " + str(id_list) +
+              ". Accession some more samples in ELN grabber and run this again and check continuity.")
+        self.assertEqual(len(id_list), 5)
+
+    def test_plate_id_nonunique_accession(self):
+        """
+        This will test the platform accessioning plate IDs.
+        """
+        # This is from MultiLayerPlatingConfigManager
+        id_list = accession_service.get_global_affixed_id_in_batch(5, "", "", 4, 1000)
+        print("New Plate IDs: " + str(id_list) + ". Check continuty in ELN using 3d plating auto accession plate ID, then make sure the plate ID is non-unique.")
+        self.assertEqual(len(id_list), 5)
+
+    def test_accession_pool_ids(self):
+        # This is from CreateBoolBase, and MultiLayerPlatingRecordManager
+        id_list = accession_service.get_affixed_id_in_batch(SampleModel.DATA_TYPE_NAME, SampleModel.SAMPLEID__FIELD_NAME.field_name,
+                                                            10, "Pool-", "", None, 1000)
+        print("New Pool IDs: " + str(id_list))
+        self.assertEqual(len(id_list), 10)

{sapiopycommons-2024.6.29a275 → sapiopycommons-2024.7.2a279}/tests/chem_test.py

@@ -6,11 +6,12 @@ from sapiopylib.rest.ClientCallbackService import ClientCallback
 from sapiopylib.rest.DataMgmtService import DataMgmtServer
 from sapiopylib.rest.DataTypeService import DataTypeManager
 from sapiopylib.rest.WebhookService import AbstractWebhookHandler, WebhookConfiguration, WebhookServerFactory
+from sapiopylib.rest.pojo.CustomReport import RawReportTerm, RawTermOperation
 from sapiopylib.rest.pojo.datatype.FieldDefinition import VeloxDoubleFieldDefinition
 from sapiopylib.rest.pojo.webhook.ClientCallbackRequest import *
 from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.pojo.webhook.WebhookResult import SapioWebhookResult
-from sapiopylib.rest.utils.autopaging import QueryDataRecordByIdListAutoPager
+from sapiopylib.rest.utils.autopaging import QueryDataRecordByIdListAutoPager, QueryAllRecordsOfTypeAutoPager
 
 from data_type_models import *
 from sapiopycommons.multimodal.multimodal import MultiModalManager
@@ -173,6 +174,28 @@ def structure_search(context: SapioWebhookContext) -> SapioWebhookResult:
             return SapioWebhookResult(True)
 
 
+def export_sdf(context: SapioWebhookContext) -> SapioWebhookResult:
+    user = context.user
+    custom_report_manager = DataMgmtServer.get_custom_report_manager(user)
+    client_callback = DataMgmtServer.get_client_callback(user)
+    report = custom_report_manager.run_quick_report(RawReportTerm(ChemicalReagentPartModel.DATA_TYPE_NAME, "RecordId", RawTermOperation.GREATER_THAN_OPERATOR, "0"), 100, 0)
+    result_table: list[list[Any]] = report.result_table
+    record_id_col_index: int = [idx for idx, x in enumerate(report.column_list) if x.data_field_name == "RecordId"][0]
+    record_id_list = [int(x[record_id_col_index]) for x in result_table if x[record_id_col_index] is not None]
+    if not record_id_list:
+        client_callback.display_warning("There are no Chemical Reagent Part to test with. Please register at least 1 such record and test again.")
+        return SapioWebhookResult(True)
+    custom_payload: dict[int, dict[str, str]] = dict()
+    for i, record_id in enumerate(record_id_list):
+        custom_payload[record_id] = {"pyIndex": str(i)}
+    request = ChemExportSDFRequest(ChemicalReagentPartModel.DATA_TYPE_NAME, record_id_list,
+                                   additionalPropertiesByRecordId=custom_payload)
+    sdf_text = MultiModalManager(user).export_to_sdf(request)
+    with BytesIO(sdf_text.encode()) as io:
+        client_callback.send_file("output.sdf", False, io)
+    return SapioWebhookResult(True)
+
+
 class ChemistryRegistrationTestHandler(AbstractWebhookHandler):
     """
     This one will test the facilities to parse a chemical structure and return a svg file to user's browser.
@@ -180,7 +203,7 @@ class ChemistryRegistrationTestHandler(AbstractWebhookHandler):
 
     def run(self, context: SapioWebhookContext) -> SapioWebhookResult:
         options = ['Download Image', 'Register Non-Interactively', 'Structure Search',
-                   'Register Reaction']
+                   'Register Reaction', "Export SDF"]
         user = context.user
         client_callback = DataMgmtServer.get_client_callback(user)
         selected = client_callback.show_option_dialog(OptionDialogRequest(
@@ -195,6 +218,8 @@ class ChemistryRegistrationTestHandler(AbstractWebhookHandler):
             return structure_search(context)
         elif selected == 3:
             return register_reaction(context)
+        elif selected == 4:
+            return export_sdf(context)
         return SapioWebhookResult(False)
 
 config: WebhookConfiguration = WebhookConfiguration(verify_sapio_cert=False, debug=True)