dxpy 0.396.0__tar.gz → 0.398.0__tar.gz

{dxpy-0.396.0 → dxpy-0.398.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dxpy
-Version: 0.396.0
+Version: 0.398.0
 Summary: DNAnexus Platform API bindings for Python
 Home-page: https://github.com/dnanexus/dx-toolkit
 Author: Aleksandra Zalcman, Andrey Kislyuk, Anurag Biyani, Geet Duggal, Katherine Lai, Kurt Jensen, Marek Hrvol, Ohad Rodeh, Phil Sung

{dxpy-0.396.0 → dxpy-0.398.0}/dxpy/__init__.py

@@ -993,7 +993,7 @@ def get_auth_server_name(host_override=None, port_override=None, protocol='https
         return 'https://stagingauth.cn.dnanexus.com:7001'
     elif APISERVER_HOST == 'api.cn.dnanexus.com':
         return 'https://auth.cn.dnanexus.com:8001'
-    elif APISERVER_HOST == "localhost" or APISERVER_HOST == "127.0.0.1":
+    elif APISERVER_HOST == "localhost" or APISERVER_HOST == "127.0.0.1" or APISERVER_HOST == "apiserver":
         if "DX_AUTHSERVER_HOST" not in os.environ or "DX_AUTHSERVER_PORT" not in os.environ:
             err_msg = "Must set authserver env vars (DX_AUTHSERVER_HOST, DX_AUTHSERVER_PORT) if apiserver is {apiserver}."
             raise exceptions.DXError(err_msg.format(apiserver=APISERVER_HOST))

{dxpy-0.396.0 → dxpy-0.398.0}/dxpy/bindings/apollo/dataset.py

@@ -77,7 +77,7 @@ class Dataset(DXRecord):
     @property
     def version(self):
         return self.detail_describe.get("details").get("version")
-    
+
     @property
     def detail_describe(self):
         if self._detail_describe is None:
@@ -98,6 +98,9 @@ class Dataset(DXRecord):
                 "index": index,
                 "uuid": assays[index]["uuid"],
                 "reference": assays[index].get("reference"),
+                "generalized_assay_model_version": assays[index].get(
+                    "generalized_assay_model_version"
+                ),
             }
 
             if model not in assays_info_dict.keys():
@@ -107,6 +110,12 @@ class Dataset(DXRecord):
 
         return assays_info_dict
 
+    def assay_info_dict(self, assay_uuid):
+        for assay_list in self.assays_info_dict.values():
+            for assay in assay_list:
+                if assay["uuid"] == assay_uuid:
+                    return assay
+
     def assay_names_list(self, assay_type):
         assay_names_list = []
         if self.assays_info_dict.get(assay_type):

{dxpy-0.396.0 → dxpy-0.398.0}/dxpy/bindings/apollo/json_validation_by_schema.py

@@ -99,8 +99,10 @@ class JSONValidator(object):
 
                 # Check for incompatible/conflicting subkeys defined at the key-level
                 if value.get("conflicting_keys"):
+                    self.check_incompatible_subkeys(input_json, key)
                     self.check_incompatible_subkeys(input_json[key], key)
 
+
         self.check_incompatible_keys(input_json)
         self.check_dependent_key_combinations(input_json)
 

dxpy-0.398.0/dxpy/bindings/apollo/schemas/assay_filtering_conditions.py

@@ -0,0 +1,213 @@
+EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_0 = {
+    "version": "1.0",
+    "output_fields_mapping": {
+        "default": [
+            {"feature_id": "expression$feature_id"},
+            {"sample_id": "expression$sample_id"},
+            {"expression": "expression$value"},
+        ],
+        "additional": [
+            {"feature_name": "expr_annotation$gene_name"},
+            {"chrom": "expr_annotation$chr"},
+            {"start": "expr_annotation$start"},
+            {"end": "expr_annotation$end"},
+            {"strand": "expr_annotation$strand"},
+        ],
+    },
+    "filtering_conditions": {
+        "location": {
+            "items_combination_operator": "or",
+            "filters_combination_operator": "and",
+            "max_item_limit": 10,
+            "properties": [
+                {
+                    "key": "chromosome",
+                    "condition": "is",
+                    "table_column": "expr_annotation$chr",
+                },
+                {
+                    "keys": ["starting_position", "ending_position"],
+                    "condition": "genobin_partial_overlap",
+                    "max_range": "250",
+                    "table_column": {
+                        "starting_position": "expr_annotation$start",
+                        "ending_position": "expr_annotation$end",
+                    },
+                },
+            ],
+        },
+        "annotation": {
+            "properties": {
+                "feature_id": {
+                    "max_item_limit": 100,
+                    "condition": "in",
+                    "table_column": "expr_annotation$feature_id",
+                },
+                "feature_name": {
+                    "max_item_limit": 100,
+                    "condition": "in",
+                    "table_column": "expr_annotation$gene_name",
+                },
+            }
+        },
+        "expression": {
+            "filters_combination_operator": "and",
+            "properties": {
+                "min_value": {
+                    "condition": "greater-than-eq",
+                    "table_column": "expression$value",
+                },
+                "max_value": {
+                    "condition": "less-than-eq",
+                    "table_column": "expression$value",
+                },
+            },
+        },
+        "sample_id": {
+            "max_item_limit": 100,
+            "condition": "in",
+            "table_column": "expression$sample_id",
+        },
+    },
+    "filters_combination_operator": "and",
+    "order_by": [
+        {"feature_id": "asc"},
+        {"sample_id": "asc"},
+    ],
+}
+
+# EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1 does not handle optimization of location filters
+EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1 = {
+    "version": "1.1",
+    "output_fields_mapping": {
+        "default": [
+            {"feature_id": "expression_read_optimized$feature_id"},
+            {"sample_id": "expression_read_optimized$sample_id"},
+            {"expression": "expression_read_optimized$value"},
+        ],
+        "additional": [
+            {"feature_name": "expression_read_optimized$gene_name"},
+            {"chrom": "expression_read_optimized$CHROM"},
+            {"start": "expression_read_optimized$start"},
+            {"end": "expression_read_optimized$end"},
+            {"strand": "expression_read_optimized$strand"},
+        ],
+    },
+    "filtering_conditions": {
+        "annotation": {
+            "properties": {
+                "feature_id": {
+                    "max_item_limit": 100,
+                    "condition": "in",
+                    "table_column": "expression_read_optimized$feature_id",
+                },
+                "feature_name": {
+                    "max_item_limit": 100,
+                    "condition": "in",
+                    "table_column": "expression_read_optimized$gene_name",
+                },
+            }
+        },
+        "expression": {
+            "filters_combination_operator": "and",
+            "properties": {
+                "min_value": {
+                    "condition": "greater-than-eq",
+                    "table_column": "expression_read_optimized$value",
+                },
+                "max_value": {
+                    "condition": "less-than-eq",
+                    "table_column": "expression_read_optimized$value",
+                },
+            },
+        },
+        "sample_id": {
+            "max_item_limit": 100,
+            "condition": "in",
+            "table_column": "expression_read_optimized$sample_id",
+        },
+    },
+    "filters_combination_operator": "and",
+    "order_by": [
+        {"feature_id": "asc"},
+        {"sample_id": "asc"},
+    ],
+}
+
+EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1_non_optimized = {
+    "version": "1.1",
+    "output_fields_mapping": {
+        "default": [
+            {"feature_id": "expression$feature_id"},
+            {"sample_id": "expression$sample_id"},
+            {"expression": "expression$value"},
+        ],
+        "additional": [
+            {"feature_name": "expr_annotation$gene_name"},
+            {"chrom": "expr_annotation$CHROM"},
+            {"start": "expr_annotation$start"},
+            {"end": "expr_annotation$end"},
+            {"strand": "expr_annotation$strand"},
+        ],
+    },
+    "filtering_conditions": {
+        "location": {
+            "items_combination_operator": "or",
+            "filters_combination_operator": "and",
+            "max_item_limit": 10,
+            "properties": [
+                {
+                    "key": "chromosome",
+                    "condition": "is",
+                    "table_column": "expr_annotation$CHROM",
+                },
+                {
+                    "keys": ["starting_position", "ending_position"],
+                    "condition": "genobin_partial_overlap",
+                    "max_range": "250",
+                    "table_column": {
+                        "starting_position": "expr_annotation$start",
+                        "ending_position": "expr_annotation$end",
+                    },
+                },
+            ],
+        },
+        "annotation": {
+            "properties": {
+                "feature_id": {
+                    "max_item_limit": 100,
+                    "condition": "in",
+                    "table_column": "expr_annotation$feature_id",
+                },
+                "feature_name": {
+                    "max_item_limit": 100,
+                    "condition": "in",
+                    "table_column": "expr_annotation$gene_name",
+                },
+            }
+        },
+        "expression": {
+            "filters_combination_operator": "and",
+            "properties": {
+                "min_value": {
+                    "condition": "greater-than-eq",
+                    "table_column": "expression$value",
+                },
+                "max_value": {
+                    "condition": "less-than-eq",
+                    "table_column": "expression$value",
+                },
+            },
+        },
+        "sample_id": {
+            "max_item_limit": 100,
+            "condition": "in",
+            "table_column": "expression$sample_id",
+        },
+    },
+    "filters_combination_operator": "and",
+    "order_by": [
+        {"feature_id": "asc"},
+        {"sample_id": "asc"},
+    ],
+}

{dxpy-0.396.0 → dxpy-0.398.0}/dxpy/bindings/apollo/schemas/assay_filtering_json_schemas.py

@@ -9,7 +9,10 @@ EXTRACT_ASSAY_EXPRESSION_JSON_SCHEMA = {
     },
     "expression": {
         "type": dict,
-        "properties": {"min_value": {"type": (int, float)}, "max_value": {"type": (int, float)}},
+        "properties": {
+            "min_value": {"type": (int, float)},
+            "max_value": {"type": (int, float)},
+        },
     },
     "location": {
         "type": list,
@@ -26,5 +29,8 @@ EXTRACT_ASSAY_EXPRESSION_JSON_SCHEMA = {
         "type": list,
     },
     "conflicting_keys": [["location", "annotation"]],
-    "dependent_conditional_keys": {"expression": ["annotation", "location"]},
+    "dependent_conditional_keys": {
+        "expression": ["annotation", "location"],
+        "sample_id": ["expression", "annotation", "location"],
+    },
 }

{dxpy-0.396.0 → dxpy-0.398.0}/dxpy/bindings/apollo/schemas/input_arguments_validation_schemas.py

@@ -59,11 +59,12 @@ EXTRACT_ASSAY_EXPRESSION_INPUT_ARGS_SCHEMA = {
                 "filter_json_file",
                 "json_help",
                 "additional_fields_help",
+                "sql"
             ],
         },
         "condition": "with_at_least_one_required",
         "error_message": {
-            "message": 'The flag "--retrieve_expression" must be followed by "--filter-json", "--filter-json-file", "--json-help", or "--additional-fields-help".'
+            "message": 'The flag "--retrieve_expression" must be followed by "--sql", "--filter-json", "--filter-json-file", "--json-help", or "--additional-fields-help".'
         },
     },
     "5_json_help_exclusive_with_exceptions": {

{dxpy-0.396.0 → dxpy-0.398.0}/dxpy/bindings/apollo/vizserver_filters_from_json_parser.py

@@ -5,15 +5,16 @@ class JSONFiltersValidator(object):
     """
     A specialized class that parses user input JSON according to a schema to prepare vizserver-compliant compound filters.
 
-    See assay_filtering_conditions.py for current schemas.
+    See assay_filtering_conditions.py for current schemas, which include optimized schema EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1
+    and non-optimized EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1_non_optimized to handle location filters.
 
     Filters must be defined in schema["filtering_conditions"]
 
-    There are currently three ways to define filtering_conditions when version is 1.0:
+    There are currently three ways to define filtering_conditions when version is 1.1:
     1. Basic use-case: no "properties" are defined. Only "condition", "table_column" and optionally "max_item_limit" are defined.
                        In this case, there are no sub-keys for the current key in input_json.
-                       (see 'sample_id' in 'assay_filtering_conditions.EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS')
-    2. Properties defined as dict of dicts (see 'annotation' and 'expression' in EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS)
+                       (see 'sample_id' in 'assay_filtering_conditions.EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1')
+    2. Properties defined as dict of dicts (see 'annotation' and 'expression' in EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1)
         2.1. If filters_combination_operator is not defined, the assumption is that there is only one sub-key in input_json
 
     3. Complex use-case: Properties defined as list of dicts (more advanced, special use-case with complex conditional logics that needs translation)
@@ -21,7 +22,7 @@ class JSONFiltersValidator(object):
         In this case, the schema must define "items_combination_operator" and "filters_combination_operator".
         items_combination_operator: how to combine filters for list items in input_json
         filters_combination_operator: how to combine filters within each item
-        (see 'location' in EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS)
+        (see 'location' in EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1_non_optimized)
 
         Within 'properties' if "key" is defined, then a generic one-key filter is built.
         If "keys" is defined, then more complex use-cases are handled via special conditions that are defined in condition_function_mapping.
@@ -66,14 +67,21 @@ class JSONFiltersValidator(object):
 
     def parse(self):
         self.is_valid_json(self.schema)
-        if self.get_schema_version(self.schema) == "1.0":
-            return self.parse_v1()
+        if self.get_schema_version(self.schema).startswith("1."):
+            return self.parse_v1_1()
         else:
             raise NotImplementedError
 
+    def parse_v1_1(self):
+        """
+        Parse input_json according to schema version 1.1 (optimized), and build vizserver compound filters. In this version,
+        compound filters are built in one hash.
+        """
+        return self.merge_duplicate_filters(self.parse_v1())
+
     def parse_v1(self):
         """
-        Parse input_json according to schema version 1.0, and build vizserver compound filters.
+        Parse input_json according to schema version 1.0 (non-optimized), and build vizserver compound filters.
         """
 
         try:
@@ -85,8 +93,8 @@ class JSONFiltersValidator(object):
 
             # Go through the input_json (iterate through keys and values in user input JSON)
             for filter_key, filter_values in self.input_json.items():
-                # Example: if schema is EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS
-                # Then input JSON would probably contain location or annotation
+                # Example: if schema is EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1_non_optimized
+                # Then input JSON would contain location and maybe others such as annotation
                 # In this case:
                 # filter_key -> location
                 # filter_values -> list of dicts (where each dict contains "chromosome", "starting_position", "ending_position")
@@ -111,7 +119,7 @@ class JSONFiltersValidator(object):
                 self.validate_max_item_limit(current_filters, filter_values, filter_key)
 
                 # There are several ways filtering_conditions can be defined
-                # 1. Basic use-case: no properties, just condition (see 'sample_id' in 'EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS')
+                # 1. Basic use-case: no properties, just condition (see 'sample_id' in 'EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1')
                 # 2. Properties defined as dict of dicts (see 'annotation' and 'expression')
                 # 3. Properties defined as list of dicts (more advanced, special use-case with complex conditional logics that needs translation)
                 # For more information see the docstring of the class
@@ -146,7 +154,7 @@ class JSONFiltersValidator(object):
                     # no properties, so just apply conditions
                     # In other words .get("properties") returns None
                     # Therefore we are dealing with a basic use-case scenario
-                    # (See 'sample_id' in 'EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS' for an example)
+                    # (See 'sample_id' in 'EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1' for an example)
                     filters = self.build_one_key_generic_filter(
                         current_filters.get("table_column"),
                         current_filters.get("condition"),
@@ -262,7 +270,7 @@ class JSONFiltersValidator(object):
 
                 # check if there are two filtering conditions that need to be applied on the same table_column
                 # check if both of those are defined in input_json
-                # an example of such a case is 'expression' in EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS
+                # an example of such a case is 'expression' in EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1
                 # where we might have a `max_value` and a `min_value`
                 # however providing both is not mandatory
 
@@ -311,7 +319,7 @@ class JSONFiltersValidator(object):
 
         else:
             # There's no filtering logic, in other words, filters_combination_operator is not defined at this level
-            # (see 'annotation' in 'EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS' for an example)
+            # (see 'annotation' in 'EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1' for an example)
             if len(current_properties) > 1:
                 if len(filter_values) > 1:
                     # if there are also more than 1 in input_json
@@ -521,3 +529,74 @@ class JSONFiltersValidator(object):
         # }
 
         return filter_structure
+
+    def merge_duplicate_filters(self, compound_block):
+        """
+        Recursively walk the compound tree and merge duplicate 'filters' blocks
+        at the same compound level.
+
+        Example usage:
+        # For
+        compound_block = 
+                    {
+                "logic": "and",
+                "compound": [
+                    {
+                        "filters": {
+                            "expression_read_optimized$value": [
+                                {"condition": "greater-than-eq", "values": 2000}
+                            ]
+                        }
+                    },
+                    {
+                        "filters": {
+                            "expression_read_optimized$gene_name": [
+                                {"condition": "in", "values": ["FAM229B", "TRAIP", "PLEC"]}
+                            ]
+                        }
+                    },
+                ],
+            }
+        merged_block = merge_duplicate_filters(compound_block)
+
+        # merged_block will be:
+        {
+            "logic": "and",
+            "compound": [
+                {
+                    "filters": {
+                        "expression_read_optimized$value": [
+                            {"condition": "greater-than-eq", "values": 2000}
+                        ],
+                        "expression_read_optimized$gene_name": [
+                            {"condition": "in", "values": ["FAM229B", "TRAIP", "PLEC"]}
+                        ],
+                    }
+                }
+            ],
+        }
+        """
+        if "compound" in compound_block:
+            new_compound = []
+            merged_filters = {}
+
+            for item in compound_block["compound"]:
+                self.merge_duplicate_filters(item)
+
+                if "filters" in item and len(item) == 1:
+                    # Merge filters into the accumulating dict
+                    for key, conditions in item["filters"].items():
+                        merged_filters[key] = []
+                        merged_filters[key].extend(conditions)
+                else:
+                    if merged_filters:
+                        new_compound.append({"filters": merged_filters})
+                        merged_filters = {}
+                    new_compound.append(item)
+
+            if merged_filters:
+                new_compound.append({"filters": merged_filters})
+
+            compound_block["compound"] = new_compound
+
+        return compound_block

{dxpy-0.396.0 → dxpy-0.398.0}/dxpy/cli/dataset_utilities.py

@@ -71,7 +71,7 @@ from ..bindings.apollo.json_validation_by_schema import JSONValidator
 
 from ..bindings.apollo.schemas.input_arguments_validation_schemas import EXTRACT_ASSAY_EXPRESSION_INPUT_ARGS_SCHEMA
 from ..bindings.apollo.schemas.assay_filtering_json_schemas import EXTRACT_ASSAY_EXPRESSION_JSON_SCHEMA
-from ..bindings.apollo.schemas.assay_filtering_conditions import EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS
+from ..bindings.apollo.schemas.assay_filtering_conditions import EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_0, EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1, EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1_non_optimized
 
 from ..bindings.apollo.vizserver_filters_from_json_parser import JSONFiltersValidator
 from ..bindings.apollo.vizserver_payload_builder import VizPayloadBuilder
@@ -178,8 +178,6 @@ def raw_api_call(resp, payload, sql_message=True):
                 err_message = "Insufficient permissions due to the project policy.\n" + resp_raw["error"]["message"]
             elif sql_message and resp_raw["error"]["type"] == "QueryTimeOut":
                 err_message = "Please consider using `--sql` option to generate the SQL query and query via a private compute cluster.\n" + resp_raw["error"]["message"]        
-            elif resp_raw["error"]["type"] == "QueryBuilderError" and resp_raw["error"]["details"] == "rsid exists in request filters without rsid entries in rsid_lookup_table.":
-                err_message = "At least one rsID provided in the filter is not present in the provided dataset or cohort"
             elif resp_raw["error"]["type"] == "DxApiError":
                 err_message = resp_raw["error"]["message"]
             else:
@@ -1432,7 +1430,14 @@ def extract_assay_expression(args):
         except Exception as e:
             err_exit(str(e))
 
-    if user_filters_json == {}:
+    # If --sql flag is provided, filter JSON is optional. If not present, all data must be returned
+    if args.sql and not args.filter_json and not args.filter_json_file:
+        return_all_data = True
+        user_filters_json = {}
+    else:
+        return_all_data = False
+
+    if not user_filters_json and not return_all_data:
         err_exit(
             "No filter JSON is passed with --retrieve-expression or input JSON for --retrieve-expression does not contain valid filter information."
         )
@@ -1460,18 +1465,51 @@ def extract_assay_expression(args):
             "ending_position"
         ]["type"] = unicode
 
-    # Validate filters JSON provided by the user according to a predefined schema
-    input_json_validator = JSONValidator(
-        schema=EXTRACT_ASSAY_EXPRESSION_JSON_SCHEMA, error_handler=err_exit
-    )
-    input_json_validator.validate(input_json=user_filters_json)
+    # In case --sql flag is provided but no input json, function should return all data
+    if user_filters_json:
+        # Validate filters JSON provided by the user according to a predefined schema
+        input_json_validator = JSONValidator(
+            schema=EXTRACT_ASSAY_EXPRESSION_JSON_SCHEMA, error_handler=err_exit
+        )
+        input_json_validator.validate(input_json=user_filters_json)
+
+
+    if args.assay_name:
+        # Assumption: assay names are unique in a dataset descriptor
+        # i.e. there are never two assays of the same type with the same name in the same dataset
+        for molecular_assay in dataset.assays_info_dict["molecular_expression"]:
+            if molecular_assay["name"] == args.assay_name:
+                ASSAY_ID = molecular_assay["uuid"]
+                break
+    else:
+        ASSAY_ID = dataset.assays_info_dict["molecular_expression"][0]["uuid"]
+
+    # Getting generalized_assay_model_version to match filter schema
+    conditions_mapping = {
+            "1.0": EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_0,
+            "1.1": EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1,
+        }
+    generalized_assay_model_version = dataset.assay_info_dict(ASSAY_ID).get("generalized_assay_model_version")
+    filter_schema = conditions_mapping.get(generalized_assay_model_version)
+
+    # Genomic range limits must be applied. However, when using --sql limits may be ignored.
+    if generalized_assay_model_version == "1.1":
+        if "location" in user_filters_json:
+            filter_schema = EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1_non_optimized
+        else:
+            filter_schema = EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1
+
+    # When location filter is used and version is 1.1, or all data must be returned queries should not use optimized table
+    # Genomic range limits must be applied. However, when using --sql limits may be ignored.
+    if "location" in user_filters_json or return_all_data:
 
-    if "location" in user_filters_json:
+        if generalized_assay_model_version == "1.1":
+            filter_schema = EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS_1_1_non_optimized
+            
         if args.sql:
-            EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS["filtering_conditions"][
+            filter_schema["filtering_conditions"][
                 "location"
             ]["max_item_limit"] = None
-
         else:
             # Genomic range adding together across multiple contigs should be smaller than 250 Mbps
             input_json_validator.are_list_items_within_range(
@@ -1482,18 +1520,18 @@ def extract_assay_expression(args):
                 window_width=250000000,
                 check_each_separately=False,
             )
-
     input_json_parser = JSONFiltersValidator(
         input_json=user_filters_json,
-        schema=EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS,
+        schema=filter_schema,
         error_handler=err_exit,
     )
     vizserver_raw_filters = input_json_parser.parse()
 
-    _db_columns_list = EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS[
+    _db_columns_list = filter_schema[
         "output_fields_mapping"
     ].get("default")
 
+
     if args.additional_fields:
         # All three of the following should work:
         # --additional_fields field1 field2
@@ -1507,9 +1545,10 @@ def extract_assay_expression(args):
             field = [x.strip() for x in item.split(",") if x.strip()]
             additional_fields.extend(field)
 
-        all_additional_cols = EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS[
+        all_additional_cols = filter_schema[
             "output_fields_mapping"
         ].get("additional")
+
         incorrect_cols = set(additional_fields) - set(
             {k for d in all_additional_cols for k in d.keys()}
         )
@@ -1526,28 +1565,19 @@ def extract_assay_expression(args):
         project_context=project,
         output_fields_mapping=_db_columns_list,
         filters={"filters": COHORT_FILTERS} if IS_COHORT else None,
-        order_by=EXTRACT_ASSAY_EXPRESSION_FILTERING_CONDITIONS["order_by"],
+        order_by=filter_schema["order_by"],
         limit=None,
         base_sql=BASE_SQL,
         is_cohort=IS_COHORT,
         error_handler=err_exit,
     )
 
+
     DATASET_DESCRIPTOR = dataset.descriptor_file_dict
     ASSAY_NAME = (
         args.assay_name if args.assay_name else dataset.assay_names_list("molecular_expression")[0]
     )
 
-    if args.assay_name:
-        # Assumption: assay names are unique in a dataset descriptor
-        # i.e. there are never two assays of the same type with the same name in the same dataset
-        for molecular_assay in dataset.assays_info_dict["molecular_expression"]:
-            if molecular_assay["name"] == args.assay_name:
-                ASSAY_ID = molecular_assay["uuid"]
-                break
-    else:
-        ASSAY_ID = dataset.assays_info_dict["molecular_expression"][0]["uuid"]
-
     viz.assemble_assay_raw_filters(
         assay_name=ASSAY_NAME, assay_id=ASSAY_ID, filters=vizserver_raw_filters
     )