sapiopycommons 2024.12.5a376__tar.gz → 2024.12.9a378__tar.gz

{sapiopycommons-2024.12.5a376 → sapiopycommons-2024.12.9a378}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2024.12.5a376
+Version: 2024.12.9a378
 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.12.5a376 → sapiopycommons-2024.12.9a378}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sapiopycommons"
-version='2024.12.05a376'
+version='2024.12.09a378'
 authors = [
     { name="Jonathan Steck", email="jsteck@sapiosciences.com" },
     { name="Yechen Qiao", email="yqiao@sapiosciences.com" },

{sapiopycommons-2024.12.5a376 → sapiopycommons-2024.12.9a378}/src/sapiopycommons/customreport/custom_report_builder.py

@@ -3,6 +3,7 @@ from sapiopylib.rest.pojo.CustomReport import ReportColumn, CustomReportCriteria
 from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
 
 from sapiopycommons.customreport.column_builder import ColumnBuilder
+from sapiopycommons.customreport.term_builder import TermBuilder
 from sapiopycommons.general.aliases import DataTypeIdentifier, FieldIdentifier, AliasUtil, SapioRecord
 from sapiopycommons.general.exceptions import SapioException
 
@@ -31,6 +32,12 @@ class CustomReportBuilder:
         self.column_list = []
         self.join_list = []
 
+    def get_term_builder(self) -> TermBuilder:
+        """
+        :return: A TermBuilder with a data type matching this report builder's root data type.
+        """
+        return TermBuilder(self.root_data_type)
+
     def has_root_term(self) -> bool:
         """
         :return: Whether this report builder has had its root term set.

{sapiopycommons-2024.12.5a376 → sapiopycommons-2024.12.9a378}/src/sapiopycommons/customreport/term_builder.py

@@ -25,103 +25,119 @@ class TermBuilder:
     """
     A class that allows for the easier constructions of custom report terms.
     """
-    @staticmethod
-    def all_records_term(data_type: DataTypeIdentifier) -> RawReportTerm:
+    data_type: str
+
+    def __init__(self, data_type: DataTypeIdentifier):
+        """
+        :param data_type: An object that can be used to identify a data type name. Used as the default data type name
+            of the terms created from this TermBuilder.
+        """
+        self.data_type = AliasUtil.to_data_type_name(data_type)
+
+    def all_records_term(self, *, data_type: DataTypeIdentifier | None = None) -> RawReportTerm:
         """
         Create a raw report term that captures all records of the given data type.
 
-        :param data_type: The data type of this term.
+        :param data_type: If provided, the data type of this term. If not provided, then the data type that this term
+            builder was instantiated with is used.
         :return: A raw report term for "data_type.RecordId >= 0".
         """
-        return RawReportTerm(AliasUtil.to_data_type_name(data_type), "RecordId", GTE, TermBuilder.to_term_val(0))
+        data_type: str = AliasUtil.to_data_type_name(data_type) if data_type else self.data_type
+        return RawReportTerm(data_type, "RecordId", GTE, TermBuilder.to_term_val(0))
 
-    @staticmethod
-    def is_term(data_type: DataTypeIdentifier, field: FieldIdentifier, value: TermValue,
-                *, trim: bool = False) -> RawReportTerm:
+    def is_term(self, field: FieldIdentifier, value: TermValue,
+                *, data_type: DataTypeIdentifier | None = None, trim: bool = False) -> RawReportTerm:
         """
         Create a raw report term for comparing a field value with an equals operation.
 
-        :param data_type: The data type of this term.
         :param field: The data field of this term.
         :param value: The value to compare for this term.
+        :param data_type: If provided, the data type of this term. If not provided, then the data type that this term
+            builder was instantiated with is used.
         :param trim: Whether the string of the given value should be trimmed of trailing and leading whitespace.
         :return: A raw report term for "data_type.field = value".
         """
+        data_type: str = AliasUtil.to_data_type_name(data_type) if data_type else self.data_type
         return RawReportTerm(AliasUtil.to_data_type_name(data_type), AliasUtil.to_data_field_name(field), EQ,
                              TermBuilder.to_term_val(value), trim)
 
-    @staticmethod
-    def not_term(data_type: DataTypeIdentifier, field: FieldIdentifier, value: TermValue,
-                 *, trim: bool = False) -> RawReportTerm:
+    def not_term(self, field: FieldIdentifier, value: TermValue,
+                 *, data_type: DataTypeIdentifier | None = None, trim: bool = False) -> RawReportTerm:
         """
         Create a raw report term for comparing a field value with a not equals operation.
 
-        :param data_type: The data type of this term.
         :param field: The data field of this term.
         :param value: The value to compare for this term.
+        :param data_type: If provided, the data type of this term. If not provided, then the data type that this term
+            builder was instantiated with is used.
         :param trim: Whether the string of the given value should be trimmed of trailing and leading whitespace.
         :return: A raw report term for "data_type.field != value".
         """
+        data_type: str = AliasUtil.to_data_type_name(data_type) if data_type else self.data_type
         return RawReportTerm(AliasUtil.to_data_type_name(data_type), AliasUtil.to_data_field_name(field), NEQ,
                              TermBuilder.to_term_val(value), trim)
 
-    @staticmethod
-    def lt_term(data_type: DataTypeIdentifier, field: FieldIdentifier, value: TermValue,
-                *, trim: bool = False) -> RawReportTerm:
+    def lt_term(self, field: FieldIdentifier, value: TermValue,
+                *, data_type: DataTypeIdentifier | None = None, trim: bool = False) -> RawReportTerm:
         """
         Create a raw report term for comparing a field value with a less than operation.
 
-        :param data_type: The data type of this term.
         :param field: The data field of this term.
         :param value: The value to compare for this term.
+        :param data_type: If provided, the data type of this term. If not provided, then the data type that this term
+            builder was instantiated with is used.
         :param trim: Whether the string of the given value should be trimmed of trailing and leading whitespace.
         :return: A raw report term for "data_type.field < value".
         """
+        data_type: str = AliasUtil.to_data_type_name(data_type) if data_type else self.data_type
         return RawReportTerm(AliasUtil.to_data_type_name(data_type), AliasUtil.to_data_field_name(field), LT,
                              TermBuilder.to_term_val(value), trim)
 
-    @staticmethod
-    def lte_term(data_type: DataTypeIdentifier, field: FieldIdentifier, value: TermValue,
-                 *, trim: bool = False) -> RawReportTerm:
+    def lte_term(self, field: FieldIdentifier, value: TermValue,
+                 *, data_type: DataTypeIdentifier | None = None, trim: bool = False) -> RawReportTerm:
         """
         Create a raw report term for comparing a field value with a less than or equal to operation.
 
-        :param data_type: The data type of this term.
         :param field: The data field of this term.
         :param value: The value to compare for this term.
+        :param data_type: If provided, the data type of this term. If not provided, then the data type that this term
+            builder was instantiated with is used.
         :param trim: Whether the string of the given value should be trimmed of trailing and leading whitespace.
         :return: A raw report term for "data_type.field <= value".
         """
+        data_type: str = AliasUtil.to_data_type_name(data_type) if data_type else self.data_type
         return RawReportTerm(AliasUtil.to_data_type_name(data_type), AliasUtil.to_data_field_name(field), LTE,
                              TermBuilder.to_term_val(value), trim)
 
-    @staticmethod
-    def gt_term(data_type: DataTypeIdentifier, field: FieldIdentifier, value: TermValue,
-                *, trim: bool = False) -> RawReportTerm:
+    def gt_term(self, field: FieldIdentifier, value: TermValue,
+                *, data_type: DataTypeIdentifier | None = None, trim: bool = False) -> RawReportTerm:
         """
         Create a raw report term for comparing a field value with a greater than operation.
 
-        :param data_type: The data type of this term.
         :param field: The data field of this term.
         :param value: The value to compare for this term.
+        :param data_type: If provided, the data type of this term. If not provided, then the data type that this term
+            builder was instantiated with is used.
         :param trim: Whether the string of the given value should be trimmed of trailing and leading whitespace.
         :return: A raw report term for "data_type.field > value".
         """
+        data_type: str = AliasUtil.to_data_type_name(data_type) if data_type else self.data_type
         return RawReportTerm(AliasUtil.to_data_type_name(data_type), AliasUtil.to_data_field_name(field), GT,
                              TermBuilder.to_term_val(value), trim)
 
-    @staticmethod
-    def gte_term(data_type: DataTypeIdentifier, field: FieldIdentifier, value: TermValue,
-                 *, trim: bool = False) -> RawReportTerm:
+    def gte_term(self, field: FieldIdentifier, value: TermValue,
+                 *, data_type: DataTypeIdentifier | None = None, trim: bool = False) -> RawReportTerm:
         """
         Create a raw report term for comparing a field value with a greater than or equal to operation.
 
-        :param data_type: The data type of this term.
         :param field: The data field of this term.
         :param value: The value to compare for this term.
+        :param data_type: If provided, the data type of this term. If not provided, then the data type that this term
+            builder was instantiated with is used.
         :param trim: Whether the string of the given value should be trimmed of trailing and leading whitespace.
         :return: A raw report term for "data_type.field >= value".
         """
+        data_type: str = AliasUtil.to_data_type_name(data_type) if data_type else self.data_type
         return RawReportTerm(AliasUtil.to_data_type_name(data_type), AliasUtil.to_data_field_name(field), GTE,
                              TermBuilder.to_term_val(value), trim)
 

{sapiopycommons-2024.12.5a376 → sapiopycommons-2024.12.9a378}/src/sapiopycommons/eln/experiment_report_util.py

@@ -194,11 +194,10 @@ class ExperimentReportUtil:
             dt_to_record.setdefault(AliasUtil.to_data_type_name(record, False), []).append(record)
 
         report_builder = CustomReportBuilder(EnbEntryPseudoDef.DATA_TYPE_NAME)
+        tb = report_builder.get_term_builder()
         report_builder.add_column(EnbEntryPseudoDef.DATA_TYPE_NAME__FIELD_NAME)
         report_builder.add_column(EnbEntryPseudoDef.EXPERIMENT_ID__FIELD_NAME)
-        report_builder.set_root_term(TermBuilder.is_term(EnbEntryPseudoDef.DATA_TYPE_NAME,
-                                                         EnbEntryPseudoDef.DATA_TYPE_NAME__FIELD_NAME,
-                                                         data_types))
+        report_builder.set_root_term(tb.is_term(EnbEntryPseudoDef.DATA_TYPE_NAME__FIELD_NAME, data_types))
         criteria = report_builder.build_report_criteria()
 
         ret_val: dict[SapioRecord, int] = {}
@@ -259,9 +258,8 @@ class ExperimentReportUtil:
         exp_ids: list[int] = AliasUtil.to_notebook_ids(experiments)
 
         report_builder = CustomReportBuilder(NotebookExperimentOptionPseudoDef.DATA_TYPE_NAME)
-        root = TermBuilder.is_term(NotebookExperimentOptionPseudoDef.DATA_TYPE_NAME,
-                                   NotebookExperimentOptionPseudoDef.EXPERIMENT_ID__FIELD_NAME,
-                                   exp_ids)
+        tb = report_builder.get_term_builder()
+        root = tb.is_term(NotebookExperimentOptionPseudoDef.EXPERIMENT_ID__FIELD_NAME, exp_ids)
         report_builder.set_root_term(root)
         report_builder.add_column(NotebookExperimentOptionPseudoDef.EXPERIMENT_ID__FIELD_NAME)
         report_builder.add_column(NotebookExperimentOptionPseudoDef.OPTION_KEY__FIELD_NAME)
@@ -291,9 +289,8 @@ class ExperimentReportUtil:
         """
         entries: list[int] = AliasUtil.to_entry_ids(entries)
         report_builder = CustomReportBuilder(EnbEntryOptionsPseudoDef.DATA_TYPE_NAME)
-        root = TermBuilder.is_term(EnbEntryOptionsPseudoDef.DATA_TYPE_NAME,
-                                   EnbEntryOptionsPseudoDef.ENTRY_ID__FIELD_NAME,
-                                   entries)
+        tb = report_builder.get_term_builder()
+        root = tb.is_term(EnbEntryOptionsPseudoDef.ENTRY_ID__FIELD_NAME, entries)
         report_builder.set_root_term(root)
         report_builder.add_column(EnbEntryOptionsPseudoDef.ENTRY_ID__FIELD_NAME)
         report_builder.add_column(EnbEntryOptionsPseudoDef.ENTRY_OPTION_KEY__FIELD_NAME)
@@ -323,13 +320,12 @@ class ExperimentReportUtil:
         exp_ids: list[int] = AliasUtil.to_notebook_ids(experiments)
 
         report_builder = CustomReportBuilder(NotebookExperimentPseudoDef.DATA_TYPE_NAME)
-        root = TermBuilder.is_term(NotebookExperimentPseudoDef.DATA_TYPE_NAME,
-                                   NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME,
-                                   exp_ids)
-        report_builder.add_join(TermBuilder.compare_is_term("ELNExperiment",
-                                                            "RecordId",
-                                                            NotebookExperimentPseudoDef.DATA_TYPE_NAME,
-                                                            NotebookExperimentPseudoDef.EXPERIMENT_RECORD_ID__FIELD_NAME))
+        tb = report_builder.get_term_builder()
+        root = tb.is_term(NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME, exp_ids)
+        report_builder.add_join(tb.compare_is_term("ELNExperiment",
+                                                   "RecordId",
+                                                   NotebookExperimentPseudoDef.DATA_TYPE_NAME,
+                                                   NotebookExperimentPseudoDef.EXPERIMENT_RECORD_ID__FIELD_NAME))
         report_builder.set_root_term(root)
         report_builder.add_column(NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME)
         report_builder.add_column("TemplateExperimentName", FieldType.STRING, data_type="ELNExperiment")
@@ -474,100 +470,101 @@ class ExperimentReportUtil:
         """
         dt: str = NotebookExperimentPseudoDef.DATA_TYPE_NAME
         report_builder = CustomReportBuilder(dt)
+        tb = report_builder.get_term_builder()
         report_builder.add_column(NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME)
 
         root: AbstractReportTerm | None = None
         if criteria.notebook_ids is not None:
-            root = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME, criteria.notebook_ids)
+            root = tb.is_term(NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME, criteria.notebook_ids)
         if criteria.not_notebook_ids is not None:
-            term = TermBuilder.not_term(dt, NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME, criteria.not_notebook_ids)
+            term = tb.not_term(NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME, criteria.not_notebook_ids)
             if root is not None:
-                root = TermBuilder.and_terms(root, term)
+                root = tb.and_terms(root, term)
         if root is None:
             root = ExperimentReportUtil.all_notebook_experiments_term()
 
         if criteria.names is not None:
-            term = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.EXPERIMENT_NAME__FIELD_NAME, criteria.names)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.is_term(NotebookExperimentPseudoDef.EXPERIMENT_NAME__FIELD_NAME, criteria.names)
+            root = tb.and_terms(root, term)
         if criteria.not_names is not None:
-            term = TermBuilder.not_term(dt, NotebookExperimentPseudoDef.EXPERIMENT_NAME__FIELD_NAME, criteria.not_names)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.not_term(NotebookExperimentPseudoDef.EXPERIMENT_NAME__FIELD_NAME, criteria.not_names)
+            root = tb.and_terms(root, term)
 
         if criteria.created_by is not None:
-            term = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.CREATED_BY__FIELD_NAME, criteria.created_by)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.is_term(NotebookExperimentPseudoDef.CREATED_BY__FIELD_NAME, criteria.created_by)
+            root = tb.and_terms(root, term)
         if criteria.not_created_by is not None:
-            term = TermBuilder.not_term(dt, NotebookExperimentPseudoDef.CREATED_BY__FIELD_NAME, criteria.not_created_by)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.not_term(NotebookExperimentPseudoDef.CREATED_BY__FIELD_NAME, criteria.not_created_by)
+            root = tb.and_terms(root, term)
 
         if criteria.last_modified_by is not None:
-            term = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.LAST_MODIFIED_BY__FIELD_NAME, criteria.last_modified_by)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.is_term(NotebookExperimentPseudoDef.LAST_MODIFIED_BY__FIELD_NAME, criteria.last_modified_by)
+            root = tb.and_terms(root, term)
         if criteria.not_last_modified_by is not None:
-            term = TermBuilder.not_term(dt, NotebookExperimentPseudoDef.LAST_MODIFIED_BY__FIELD_NAME, criteria.not_last_modified_by)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.not_term(NotebookExperimentPseudoDef.LAST_MODIFIED_BY__FIELD_NAME, criteria.not_last_modified_by)
+            root = tb.and_terms(root, term)
 
         if criteria.owners is not None:
-            term = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.EXPERIMENT_OWNER__FIELD_NAME, criteria.owners)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.is_term(NotebookExperimentPseudoDef.EXPERIMENT_OWNER__FIELD_NAME, criteria.owners)
+            root = tb.and_terms(root, term)
         if criteria.not_owners is not None:
-            term = TermBuilder.not_term(dt, NotebookExperimentPseudoDef.EXPERIMENT_OWNER__FIELD_NAME, criteria.not_owners)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.not_term(NotebookExperimentPseudoDef.EXPERIMENT_OWNER__FIELD_NAME, criteria.not_owners)
+            root = tb.and_terms(root, term)
 
         if criteria.statuses is not None:
-            term = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.STATUS__FIELD_NAME, criteria.statuses)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.is_term(NotebookExperimentPseudoDef.STATUS__FIELD_NAME, criteria.statuses)
+            root = tb.and_terms(root, term)
         if criteria.not_statuses is not None:
-            term = TermBuilder.not_term(dt, NotebookExperimentPseudoDef.STATUS__FIELD_NAME, criteria.not_statuses)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.not_term(NotebookExperimentPseudoDef.STATUS__FIELD_NAME, criteria.not_statuses)
+            root = tb.and_terms(root, term)
 
         # For the template name term, we need to join on the experiment record.
         if criteria.templates is not None or criteria.not_templates is not None:
-            join = TermBuilder.compare_is_term("ELNExperiment",
-                                               "RecordId",
-                                               NotebookExperimentPseudoDef.DATA_TYPE_NAME,
-                                               NotebookExperimentPseudoDef.EXPERIMENT_RECORD_ID__FIELD_NAME)
+            join = tb.compare_is_term("ELNExperiment",
+                                      "RecordId",
+                                      NotebookExperimentPseudoDef.DATA_TYPE_NAME,
+                                      NotebookExperimentPseudoDef.EXPERIMENT_RECORD_ID__FIELD_NAME)
             report_builder.add_join(join)
         if criteria.templates is not None:
-            term = TermBuilder.is_term("ELNExperiment", "TemplateExperimentName", criteria.templates)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.is_term("TemplateExperimentName", criteria.templates, data_type="ELNExperiment")
+            root = tb.and_terms(root, term)
         if criteria.not_templates is not None:
-            term = TermBuilder.not_term("ELNExperiment", "TemplateExperimentName", criteria.not_templates)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.not_term("TemplateExperimentName", criteria.not_templates, data_type="ELNExperiment")
+            root = tb.and_terms(root, term)
 
         if criteria.is_from_template is not None:
-            term = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.IS_TEMPLATE__FIELD_NAME, criteria.is_from_template)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.is_term(NotebookExperimentPseudoDef.IS_TEMPLATE__FIELD_NAME, criteria.is_from_template)
+            root = tb.and_terms(root, term)
         if criteria.is_from_protocol_template is not None:
-            term = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.IS_PROTOCOL_TEMPLATE__FIELD_NAME, criteria.is_from_protocol_template)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.is_term(NotebookExperimentPseudoDef.IS_PROTOCOL_TEMPLATE__FIELD_NAME, criteria.is_from_protocol_template)
+            root = tb.and_terms(root, term)
         if criteria.is_modifiable is not None:
-            term = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.IS_MODIFIABLE__FIELD_NAME, criteria.is_modifiable)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.is_term(NotebookExperimentPseudoDef.IS_MODIFIABLE__FIELD_NAME, criteria.is_modifiable)
+            root = tb.and_terms(root, term)
         if criteria.is_active is not None:
-            term = TermBuilder.is_term(dt, NotebookExperimentPseudoDef.IS_ACTIVE__FIELD_NAME, criteria.is_active)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.is_term(NotebookExperimentPseudoDef.IS_ACTIVE__FIELD_NAME, criteria.is_active)
+            root = tb.and_terms(root, term)
 
         if criteria.created_after is not None:
-            term = TermBuilder.gte_term(dt, NotebookExperimentPseudoDef.DATE_CREATED__FIELD_NAME, criteria.created_after)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.gte_term(NotebookExperimentPseudoDef.DATE_CREATED__FIELD_NAME, criteria.created_after)
+            root = tb.and_terms(root, term)
         if criteria.created_before is not None:
-            term = TermBuilder.lte_term(dt, NotebookExperimentPseudoDef.DATE_CREATED__FIELD_NAME, criteria.created_before)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.lte_term(NotebookExperimentPseudoDef.DATE_CREATED__FIELD_NAME, criteria.created_before)
+            root = tb.and_terms(root, term)
 
         if criteria.last_modified_after is not None:
-            term = TermBuilder.gte_term(dt, NotebookExperimentPseudoDef.LAST_MODIFIED_DATE__FIELD_NAME, criteria.last_modified_after)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.gte_term(NotebookExperimentPseudoDef.LAST_MODIFIED_DATE__FIELD_NAME, criteria.last_modified_after)
+            root = tb.and_terms(root, term)
         if criteria.last_modified_before is not None:
-            term = TermBuilder.lte_term(dt, NotebookExperimentPseudoDef.LAST_MODIFIED_DATE__FIELD_NAME, criteria.last_modified_before)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.lte_term(NotebookExperimentPseudoDef.LAST_MODIFIED_DATE__FIELD_NAME, criteria.last_modified_before)
+            root = tb.and_terms(root, term)
 
         if criteria.due_after is not None:
-            term = TermBuilder.gte_term(dt, NotebookExperimentPseudoDef.APPROVAL_DUE_DATE__FIELD_NAME, criteria.due_after)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.gte_term(NotebookExperimentPseudoDef.APPROVAL_DUE_DATE__FIELD_NAME, criteria.due_after)
+            root = tb.and_terms(root, term)
         if criteria.due_before is not None:
-            term = TermBuilder.lte_term(dt, NotebookExperimentPseudoDef.APPROVAL_DUE_DATE__FIELD_NAME, criteria.due_before)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.lte_term(NotebookExperimentPseudoDef.APPROVAL_DUE_DATE__FIELD_NAME, criteria.due_before)
+            root = tb.and_terms(root, term)
 
         report_builder.set_root_term(root)
         return report_builder.build_report_criteria()
@@ -597,9 +594,8 @@ class ExperimentReportUtil:
         """
         :return: A report term searching for all notebook experiments.
         """
-        return TermBuilder.gte_term(NotebookExperimentPseudoDef.DATA_TYPE_NAME,
-                                    NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME,
-                                    0)
+        tb = TermBuilder(NotebookExperimentPseudoDef.DATA_TYPE_NAME)
+        return tb.gte_term(NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME, 0)
 
     @staticmethod
     def __get_record_experiment_relation_rows(user: SapioUser, data_type_name: str, record_ids: list[int] | None = None,
@@ -610,39 +606,39 @@ class ExperimentReportUtil:
         """
         assert (record_ids or exp_ids)
 
+        report_builder = CustomReportBuilder(data_type_name)
+        tb = report_builder.get_term_builder()
         if record_ids:
-            records_term = TermBuilder.is_term(data_type_name, "RecordId", record_ids)
+            records_term = tb.is_term("RecordId", record_ids)
         else:
             # Get all records of the given type
-            records_term = TermBuilder.all_records_term(data_type_name)
+            records_term = tb.all_records_term()
 
         if exp_ids:
-            exp_term = TermBuilder.is_term(NotebookExperimentPseudoDef.DATA_TYPE_NAME,
-                                           NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME,
-                                           exp_ids)
+            exp_term = tb.is_term(NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME, exp_ids,
+                                  data_type=NotebookExperimentPseudoDef.DATA_TYPE_NAME)
         else:
             # Get all experiments
             exp_term = ExperimentReportUtil.all_notebook_experiments_term()
 
-        root_term = TermBuilder.and_terms(records_term, exp_term)
+        root_term = tb.and_terms(records_term, exp_term)
 
         # Join records on the experiment entry records that correspond to them.
-        records_entry_join = TermBuilder.compare_is_term(data_type_name,
-                                                         "RecordId",
-                                                         ExperimentEntryRecordPseudoDef.DATA_TYPE_NAME,
-                                                         ExperimentEntryRecordPseudoDef.RECORD_ID__FIELD_NAME)
+        records_entry_join = tb.compare_is_term(data_type_name,
+                                                "RecordId",
+                                                ExperimentEntryRecordPseudoDef.DATA_TYPE_NAME,
+                                                ExperimentEntryRecordPseudoDef.RECORD_ID__FIELD_NAME)
         # Join entry records on the experiment entries they are in.
-        experiment_entry_enb_entry_join = TermBuilder.compare_is_term(EnbEntryPseudoDef.DATA_TYPE_NAME,
-                                                                      EnbEntryPseudoDef.ENTRY_ID__FIELD_NAME,
-                                                                      ExperimentEntryRecordPseudoDef.DATA_TYPE_NAME,
-                                                                      ExperimentEntryRecordPseudoDef.ENTRY_ID__FIELD_NAME)
+        experiment_entry_enb_entry_join = tb.compare_is_term(EnbEntryPseudoDef.DATA_TYPE_NAME,
+                                                             EnbEntryPseudoDef.ENTRY_ID__FIELD_NAME,
+                                                             ExperimentEntryRecordPseudoDef.DATA_TYPE_NAME,
+                                                             ExperimentEntryRecordPseudoDef.ENTRY_ID__FIELD_NAME)
         # Join entries on the experiments they are in.
-        enb_entry_experiment_join = TermBuilder.compare_is_term(NotebookExperimentPseudoDef.DATA_TYPE_NAME,
-                                                                NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME,
-                                                                EnbEntryPseudoDef.DATA_TYPE_NAME,
-                                                                EnbEntryPseudoDef.EXPERIMENT_ID__FIELD_NAME)
+        enb_entry_experiment_join = tb.compare_is_term(NotebookExperimentPseudoDef.DATA_TYPE_NAME,
+                                                       NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME,
+                                                       EnbEntryPseudoDef.DATA_TYPE_NAME,
+                                                       EnbEntryPseudoDef.EXPERIMENT_ID__FIELD_NAME)
 
-        report_builder = CustomReportBuilder(data_type_name)
         report_builder.set_root_term(root_term)
         report_builder.add_column("RecordId", FieldType.LONG)
         report_builder.add_column(NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME,

{sapiopycommons-2024.12.5a376 → sapiopycommons-2024.12.9a378}/src/sapiopycommons/general/audit_log.py

@@ -137,16 +137,13 @@ class AuditLogUtil:
         # Build the raw report term querying for any entry with a matching record ID value to the record ID's
         # passed in.
         record_ids = AliasUtil.to_record_ids(records)
-        root_term = TermBuilder.is_term(AuditLogPseudoDef.DATA_TYPE_NAME,
-                                        AuditLogPseudoDef.RECORD_ID__FIELD_NAME,
-                                        record_ids)
+        tb = TermBuilder(AuditLogPseudoDef.DATA_TYPE_NAME)
+        root_term = tb.is_term(AuditLogPseudoDef.RECORD_ID__FIELD_NAME, record_ids)
 
         # If the user passed in any specific fields, then we should limit the query to those fields.
         if fields:
             fields: list[str] = AliasUtil.to_data_field_names(fields)
-            field_term = TermBuilder.is_term(AuditLogPseudoDef.DATA_TYPE_NAME,
-                                             AuditLogPseudoDef.DATA_FIELD_NAME__FIELD_NAME,
-                                             fields)
+            field_term = tb.is_term(AuditLogPseudoDef.DATA_FIELD_NAME__FIELD_NAME, fields)
             root_term = TermBuilder.and_terms(root_term, field_term)
 
         return CustomReportCriteria(AuditLogUtil.report_columns(), root_term)

{sapiopycommons-2024.12.5a376 → sapiopycommons-2024.12.9a378}/src/sapiopycommons/processtracking/custom_workflow_handler.py

@@ -6,7 +6,6 @@ from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 
 from sapiopycommons.customreport.custom_report_builder import CustomReportBuilder
-from sapiopycommons.customreport.term_builder import TermBuilder
 from sapiopycommons.datatype.data_fields import ProcessQueueItemFields, SystemFields, ProcessWorkflowTrackingFields
 from sapiopycommons.general.aliases import UserIdentifier, AliasUtil, SapioRecord
 from sapiopycommons.general.custom_report_util import CustomReportUtil
@@ -338,69 +337,70 @@ class QueueItemHandler:
         """
         dt: str = ProcessQueueItemFields.DATA_TYPE_NAME
         report_builder = CustomReportBuilder(dt)
+        tb = report_builder.get_term_builder()
         report_builder.add_column(SystemFields.RECORD_ID__FIELD)
         report_builder.add_column(ProcessQueueItemFields.DATA_RECORD_ID__FIELD)
 
-        root = TermBuilder.all_records_term(dt)
+        root = tb.all_records_term()
 
         if criteria.process_names is not None:
-            term = TermBuilder.is_term(dt, ProcessQueueItemFields.PROCESS_HEADER_NAME__FIELD, criteria.process_names)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.is_term(ProcessQueueItemFields.PROCESS_HEADER_NAME__FIELD, criteria.process_names)
+            root = tb.and_terms(root, term)
         if criteria.not_process_names is not None:
-            term = TermBuilder.not_term(dt, ProcessQueueItemFields.PROCESS_HEADER_NAME__FIELD, criteria.not_process_names)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.not_term(ProcessQueueItemFields.PROCESS_HEADER_NAME__FIELD, criteria.not_process_names)
+            root = tb.and_terms(root, term)
 
         if criteria.step_names is not None:
-            term = TermBuilder.is_term(dt, ProcessQueueItemFields.WORKFLOW_HEADER_NAME__FIELD, criteria.step_names)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.is_term(ProcessQueueItemFields.WORKFLOW_HEADER_NAME__FIELD, criteria.step_names)
+            root = tb.and_terms(root, term)
         if criteria.not_step_names is not None:
-            term = TermBuilder.not_term(dt, ProcessQueueItemFields.WORKFLOW_HEADER_NAME__FIELD, criteria.not_step_names)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.not_term(ProcessQueueItemFields.WORKFLOW_HEADER_NAME__FIELD, criteria.not_step_names)
+            root = tb.and_terms(root, term)
 
         if criteria.data_type_names is not None:
-            term = TermBuilder.is_term(dt, ProcessQueueItemFields.DATA_TYPE_NAME__FIELD, criteria.data_type_names)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.is_term(ProcessQueueItemFields.DATA_TYPE_NAME__FIELD, criteria.data_type_names)
+            root = tb.and_terms(root, term)
         if criteria.not_data_type_names is not None:
-            term = TermBuilder.not_term(dt, ProcessQueueItemFields.DATA_TYPE_NAME__FIELD, criteria.not_data_type_names)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.not_term(ProcessQueueItemFields.DATA_TYPE_NAME__FIELD, criteria.not_data_type_names)
+            root = tb.and_terms(root, term)
 
         if criteria.data_record_ids is not None:
-            term = TermBuilder.is_term(dt, ProcessQueueItemFields.DATA_RECORD_ID__FIELD, criteria.data_record_ids)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.is_term(ProcessQueueItemFields.DATA_RECORD_ID__FIELD, criteria.data_record_ids)
+            root = tb.and_terms(root, term)
         if criteria.not_data_record_ids is not None:
-            term = TermBuilder.not_term(dt, ProcessQueueItemFields.DATA_RECORD_ID__FIELD, criteria.not_data_record_ids)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.not_term(ProcessQueueItemFields.DATA_RECORD_ID__FIELD, criteria.not_data_record_ids)
+            root = tb.and_terms(root, term)
 
         if criteria.assigned_to is not None:
-            term = TermBuilder.is_term(dt, ProcessQueueItemFields.ASSIGNED_TO__FIELD, criteria.assigned_to)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.is_term(ProcessQueueItemFields.ASSIGNED_TO__FIELD, criteria.assigned_to)
+            root = tb.and_terms(root, term)
         if criteria.not_assigned_to is not None:
-            term = TermBuilder.not_term(dt, ProcessQueueItemFields.ASSIGNED_TO__FIELD, criteria.not_assigned_to)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.not_term(ProcessQueueItemFields.ASSIGNED_TO__FIELD, criteria.not_assigned_to)
+            root = tb.and_terms(root, term)
 
         if criteria.launched_after is not None:
-            term = TermBuilder.gte_term(dt, ProcessQueueItemFields.LAUNCHED_DATE__FIELD, criteria.launched_after)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.gte_term(ProcessQueueItemFields.LAUNCHED_DATE__FIELD, criteria.launched_after)
+            root = tb.and_terms(root, term)
         if criteria.launched_before is not None:
-            term = TermBuilder.lte_term(dt, ProcessQueueItemFields.LAUNCHED_DATE__FIELD, criteria.launched_before)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.lte_term(ProcessQueueItemFields.LAUNCHED_DATE__FIELD, criteria.launched_before)
+            root = tb.and_terms(root, term)
 
         if criteria.scheduled_after is not None:
-            term = TermBuilder.gte_term(dt, ProcessQueueItemFields.LAUNCHED_DATE__FIELD, criteria.scheduled_after)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.gte_term(ProcessQueueItemFields.LAUNCHED_DATE__FIELD, criteria.scheduled_after)
+            root = tb.and_terms(root, term)
         if criteria.scheduled_before is not None:
-            term = TermBuilder.lte_term(dt, ProcessQueueItemFields.LAUNCHED_DATE__FIELD, criteria.scheduled_before)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.lte_term(ProcessQueueItemFields.LAUNCHED_DATE__FIELD, criteria.scheduled_before)
+            root = tb.and_terms(root, term)
 
         if criteria.shown_in_queue is not None:
-            term = TermBuilder.is_term(dt, ProcessQueueItemFields.SHOW_IN_QUEUE__FIELD, criteria.shown_in_queue)
-            root = TermBuilder.and_terms(root, term)
+            term = tb.is_term(ProcessQueueItemFields.SHOW_IN_QUEUE__FIELD, criteria.shown_in_queue)
+            root = tb.and_terms(root, term)
         if criteria.has_experiment is not None:
             if criteria.has_experiment:
-                term = TermBuilder.not_term(dt, ProcessQueueItemFields.EXPERIMENT__FIELD, None)
+                term = tb.not_term(ProcessQueueItemFields.EXPERIMENT__FIELD, None)
             else:
-                term = TermBuilder.is_term(dt, ProcessQueueItemFields.EXPERIMENT__FIELD, None)
-            root = TermBuilder.and_terms(root, term)
+                term = tb.is_term(ProcessQueueItemFields.EXPERIMENT__FIELD, None)
+            root = tb.and_terms(root, term)
 
         report_builder.set_root_term(root)
         return report_builder.build_report_criteria()