sapiopycommons 2024.8.28a313__py3-none-any.whl → 2024.8.28a314__py3-none-any.whl

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/general/custom_report_util.py

@@ -3,7 +3,7 @@ from typing import Any
 
 from sapiopylib.rest.DataMgmtService import DataMgmtServer
 from sapiopylib.rest.User import SapioUser
-from sapiopylib.rest.pojo.CustomReport import ReportColumn, CustomReport
+from sapiopylib.rest.pojo.CustomReport import ReportColumn, CustomReport, CustomReportCriteria, RawReportTerm
 from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 
 
@@ -13,7 +13,9 @@ class CustomReportUtil:
     def run_system_report(context: SapioWebhookContext | SapioUser,
                           report_name: str,
                           filters: dict[str, Iterable[Any]] | None = None,
-                          page_limit: int | None = None) -> list[dict[str, Any]]:
+                          page_limit: int | None = None,
+                          page_size: int | None = None,
+                          page_number: int | None = None) -> list[dict[str, Any]]:
         """
         Run a system report and return the results of that report as a list of dictionaries for the values of each
         column in each row.
@@ -27,26 +29,94 @@ class CustomReportUtil:
             filter on. Only those headers that both the filters and the custom report share will take effect. That is,
             any filters that have a header name that isn't in the custom report will be ignored.
         :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
+        :param page_size: The size of each page of results in the search. If None, the page size is set by the server.
+        :param page_number: The page number to start the search from, If None, starts on the first page.
         :return: The results of the report listed row by row, mapping each cell to the header it is under. The header
             values in the dicts are the data field names of the columns.
+            If two columns in the search have the same data field name but differing data type names, then the
+            dictionary key to the value in the column will be "DataTypeName.DataFieldName". For example, if you
+            had a Sample column with a data field name of Identifier and a Request column with the same data field name,
+            then the dictionary keys for these columns would be Sample.Identifier and Request.Identifier respectively.
         """
-        results = CustomReportUtil.__exhaust_system_report(context, report_name, page_limit)
+        results: tuple = CustomReportUtil.__exhaust_system_report(context, report_name, page_limit,
+                                                                  page_size, page_number)
         columns: list[ReportColumn] = results[0]
         rows: list[list[Any]] = results[1]
+        return CustomReportUtil.__process_results(rows, columns, filters)
 
-        ret: list[dict[str, Any]] = []
-        for row in rows:
-            row_data: dict[str, Any] = {}
-            filter_row: bool = False
-            for value, column in zip(row, columns):
-                header: str = column.data_field_name
-                if filters is not None and header in filters and value not in filters.get(header):
-                    filter_row = True
-                    break
-                row_data.update({header: value})
-            if filter_row is False:
-                ret.append(row_data)
-        return ret
+    @staticmethod
+    def run_custom_report(context: SapioWebhookContext | SapioUser,
+                          report_criteria: CustomReportCriteria,
+                          filters: dict[str, Iterable[Any]] | None = None,
+                          page_limit: int | None = None,
+                          page_size: int | None = None,
+                          page_number: int | None = None) -> list[dict[str, Any]]:
+        """
+        Run a custom report and return the results of that report as a list of dictionaries for the values of each
+        column in each row.
+
+        Custom reports are constructed by the caller, specifying the report terms and the columns that will be in the
+        results. They are like advanced or predefined searches from the system, except they are constructed from
+        within the webhook instead of from within the system.
+
+        :param context: The current webhook context or a user object to send requests from.
+        :param report_criteria: The custom report criteria to run.
+        :param filters: If provided, filter the results of the report using the given mapping of headers to values to
+            filter on. Only those headers that both the filters and the custom report share will take effect. That is,
+            any filters that have a header name that isn't in the custom report will be ignored.
+            Note that this parameter is only provided for parity with the other run report functions. If you need to
+            filter the results of a search, it would likely be more beneficial to have just added a new term to the
+            input report criteria that corresponds to the filter.
+        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
+        :param page_size: The size of each page of results in the search. If None, uses the value from the given report
+            criteria. If not None, overwrites the value from the given report criteria.
+        :param page_number: The page number to start the search from, If None, uses the value from the given report
+            criteria. If not None, overwrites the value from the given report criteria.
+        :return: The results of the report listed row by row, mapping each cell to the header it is under. The header
+            values in the dicts are the data field names of the columns.
+            If two columns in the search have the same data field name but differing data type names, then the
+            dictionary key to the value in the column will be "DataTypeName.DataFieldName". For example, if you
+            had a Sample column with a data field name of Identifier and a Request column with the same data field name,
+            then the dictionary keys for these columns would be Sample.Identifier and Request.Identifier respectively.
+        """
+        results: tuple = CustomReportUtil.__exhaust_custom_report(context, report_criteria, page_limit,
+                                                                  page_size, page_number)
+        columns: list[ReportColumn] = results[0]
+        rows: list[list[Any]] = results[1]
+        return CustomReportUtil.__process_results(rows, columns, filters)
+
+    @staticmethod
+    def run_quick_report(context: SapioWebhookContext | SapioUser,
+                         report_term: RawReportTerm,
+                         filters: dict[str, Iterable[Any]] | None = None,
+                         page_limit: int | None = None,
+                         page_size: int | None = None,
+                         page_number: int | None = None) -> list[dict[str, Any]]:
+        """
+        Run a quick report and return the results of that report as a list of dictionaries for the values of each
+        column in each row.
+
+        Quick reports are helpful for cases where you need to query record field values in a more complex manner than
+        the data record manager allows, but still simpler than a full-blown custom report. The columns that are returned
+        in a quick search are every visible field from the data type that corresponds to the given report term. (Fields
+        which are not marked as visible in the data designer will be excluded.)
+
+        :param context: The current webhook context or a user object to send requests from.
+        :param report_term: The raw report term to use for the quick report.
+        :param filters: If provided, filter the results of the report using the given mapping of headers to values to
+            filter on. Only those headers that both the filters and the custom report share will take effect. That is,
+            any filters that have a header name that isn't in the custom report will be ignored.
+        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
+        :param page_size: The size of each page of results in the search. If None, the page size is set by the server.
+        :param page_number: The page number to start the search from, If None, starts on the first page.
+        :return: The results of the report listed row by row, mapping each cell to the header it is under. The header
+            values in the dicts are the data field names of the columns.
+        """
+        results: tuple = CustomReportUtil.__exhaust_quick_report(context, report_term, page_limit,
+                                                                 page_size, page_number)
+        columns: list[ReportColumn] = results[0]
+        rows: list[list[Any]] = results[1]
+        return CustomReportUtil.__process_results(rows, columns, filters)
 
     @staticmethod
     def get_system_report_criteria(context: SapioWebhookContext | SapioUser, report_name: str) -> CustomReport:
@@ -69,22 +139,124 @@ class CustomReportUtil:
         return report_man.run_system_report_by_name(report_name, 1, 1)
 
     @staticmethod
-    def __exhaust_system_report(context: SapioWebhookContext | SapioUser, report_name: str, page_limit: int | None = None) \
+    def __exhaust_system_report(context: SapioWebhookContext | SapioUser,
+                                report_name: str,
+                                page_limit: int | None,
+                                page_size: int | None,
+                                page_number: int | None) \
             -> tuple[list[ReportColumn], list[list[Any]]]:
+        """
+        Given a system report, iterate over every page of the report and collect the results
+        until there are no remaining pages.
+        """
         user: SapioUser = context if isinstance(context, SapioUser) else context.user
         report_man = DataMgmtServer.get_custom_report_manager(user)
 
-        report = None
-        page_size: int | None = None
-        page_number: int | None = None
+        result = None
         has_next_page: bool = True
         rows: list[list[Any]] = []
         cur_page: int = 1
-        while has_next_page and (not page_limit or cur_page < page_limit):
-            report = report_man.run_system_report_by_name(report_name, page_size, page_number)
-            page_size = report.page_size
-            page_number = report.page_number
-            has_next_page = report.has_next_page
-            rows.extend(report.result_table)
+        while has_next_page and (not page_limit or cur_page <= page_limit):
+            result = report_man.run_system_report_by_name(report_name, page_size, page_number)
+            page_size = result.page_size
+            page_number = result.page_number
+            has_next_page = result.has_next_page
+            rows.extend(result.result_table)
             cur_page += 1
-        return report.column_list, rows
+        return result.column_list, rows
+
+    @staticmethod
+    def __exhaust_custom_report(context: SapioWebhookContext | SapioUser,
+                                report: CustomReportCriteria,
+                                page_limit: int | None,
+                                page_size: int | None,
+                                page_number: int | None) \
+            -> tuple[list[ReportColumn], list[list[Any]]]:
+        """
+        Given a custom report, iterate over every page of the report and collect the results
+        until there are no remaining pages.
+        """
+        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        report_man = DataMgmtServer.get_custom_report_manager(user)
+
+        result = None
+        if page_size is not None:
+            report.page_size = page_size
+        if page_number is not None:
+            report.page_number = page_number
+        has_next_page: bool = True
+        rows: list[list[Any]] = []
+        cur_page: int = 1
+        while has_next_page and (not page_limit or cur_page <= page_limit):
+            result = report_man.run_custom_report(report)
+            report.page_size = result.page_size
+            report.page_number = result.page_number
+            has_next_page = result.has_next_page
+            rows.extend(result.result_table)
+            cur_page += 1
+        return result.column_list, rows
+
+    @staticmethod
+    def __exhaust_quick_report(context: SapioWebhookContext | SapioUser,
+                               report_term: RawReportTerm,
+                               page_limit: int | None,
+                               page_size: int | None,
+                               page_number: int | None) \
+            -> tuple[list[ReportColumn], list[list[Any]]]:
+        """
+        Given a quick report, iterate over every page of the report and collect the results
+        until there are no remaining pages.
+        """
+        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        report_man = DataMgmtServer.get_custom_report_manager(user)
+
+        result = None
+        has_next_page: bool = True
+        rows: list[list[Any]] = []
+        cur_page: int = 1
+        while has_next_page and (not page_limit or cur_page <= page_limit):
+            result = report_man.run_quick_report(report_term, page_size, page_number)
+            page_size = result.page_size
+            page_number = result.page_number
+            has_next_page = result.has_next_page
+            rows.extend(result.result_table)
+            cur_page += 1
+        return result.column_list, rows
+
+    @staticmethod
+    def __process_results(rows: list[list[Any]], columns: list[ReportColumn],
+                          filters: dict[str, Iterable[Any]] | None) -> list[dict[str, Any]]:
+        """
+        Given the results of a report as a list of row values and the report's columns, combine these lists to
+        result in a singular list of dictionaries for each row in the results.
+
+        If any filter criteria has been provided, also use that to filter the row.
+        """
+        # It may be the case that two columns have the same data field name but differing data type names.
+        # If this occurs, then we need to be able to differentiate these columns in the resulting dictionary.
+        prepend_dt: set[str] = set()
+        encountered_names: list[str] = []
+        for column in columns:
+            field_name: str = column.data_field_name
+            if field_name in encountered_names:
+                prepend_dt.add(field_name)
+            else:
+                encountered_names.append(field_name)
+
+        ret: list[dict[str, Any]] = []
+        for row in rows:
+            row_data: dict[str, Any] = {}
+            filter_row: bool = False
+            for value, column in zip(row, columns):
+                header: str = column.data_field_name
+                # If two columns share the same data field name, prepend the data type name of the column to the
+                # data field name.
+                if header in prepend_dt:
+                    header = column.data_type_name + "." + header
+                if filters is not None and header in filters and value not in filters.get(header):
+                    filter_row = True
+                    break
+                row_data.update({header: value})
+            if filter_row is False:
+                ret.append(row_data)
+        return ret