cdapython 2.0.2__py3-none-any.whl → 2.0.4__py3-none-any.whl

cdapython/get_data.py

@@ -510,8 +510,7 @@ def get_data(
     # Validate and normalize match_all filter strings; save results as a list of statement strings.
 
     try:
-        # TO DO: RE-ENABLE enforce_column_uniqueness AFTER FIGURING OUT NUMERIC HANDLING AND COMPATIBILITY BETWEEN GET_DATA AND SUMMARIZE
-        queries_for_match_all = validate_and_transform_match_filter_list( cached_column_metadata, match_all, enforce_column_uniqueness=False )
+        queries_for_match_all = validate_and_transform_match_filter_list( cached_column_metadata, match_all, enforce_column_uniqueness=True )
     except Exception as e:
         log.error( e )
         return

cdapython/summarize.py

@@ -1056,8 +1056,7 @@ def summarize(
     # ...and save parse results for each filter expression as a separate Query object (to be combined later).
 
     try:
-        # TO DO: RE-ENABLE enforce_column_uniqueness AFTER FIGURING OUT NUMERIC HANDLING AND COMPATIBILITY BETWEEN GET_DATA AND SUMMARIZE
-        queries_for_match_all = validate_and_transform_match_filter_list( cached_column_metadata, match_all, enforce_column_uniqueness=False )
+        queries_for_match_all = validate_and_transform_match_filter_list( cached_column_metadata, match_all, enforce_column_uniqueness=True )
     except Exception as e:
         log.error( e )
         return

cdapython/validation.py

@@ -152,43 +152,13 @@ def validate_and_transform_match_filter_list( cached_column_metadata, match_stat
         'f': 'false'
     }
 
-    # Intercept filter expressions of the form <numeric literal> <comparison operator> <column name> <comparison operator> <numeric literal>
-    # and split each into two two-term/one-operator comparisons, marking the field as exempt from potential column uniqueness
-    # constraints (unless there are more top-level filters on this column in addition to the first 'X <= column < Y' expression encountered)
-    column_names_exempt_from_uniqueness_check = set()
-    new_match_statement_list = list()
-
-    for filter_expression in match_statement_list:
-        match_result = re.search( r'^(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S.*)$', filter_expression ) if isinstance( filter_expression, str ) else None
-        if match_result is not None:
-            left_numeric = match_result.group(1)
-            left_operator = match_result.group(2)
-            column_name = match_result.group(3)
-            right_operator = match_result.group(4)
-            right_numeric = match_result.group(5)
-            if re.search( r'^[-+]?\d+(\.\d+)?$', left_numeric ) is None or re.search( r'^[-+]?\d+(\.\d+)?$', right_numeric ) is None or \
-                left_operator not in comparison_operators or right_operator not in comparison_operators:
-                # This is not a numeric comparison of the type we seek. Pass it along to downstream validation.
-                new_match_statement_list.append( filter_expression )
-            else:
-                # If we're enforcing column uniqueness, then at this level, whatever happens to a ternary filter downstream, we
-                # still only want to see each column filtered via at most one filter expression.
-                if enforce_column_uniqueness and column_name in column_names_exempt_from_uniqueness_check:
-                    raise RuntimeError( f"Requested column '{filter_column_name}' cannot be used twice in a 'match_all' list." )
-                else:
-                    column_names_exempt_from_uniqueness_check.add( column_name )
-                new_match_statement_list.append( f"{column_name} {flip_comparison_operator[left_operator]} {left_numeric}" )
-                new_match_statement_list.append( f"{column_name} {right_operator} {right_numeric}" )
-        else:
-            new_match_statement_list.append( filter_expression )
-
-    match_statement_list = new_match_statement_list
-
-    # Track which columns have been seen in case we need to catch disallowed sets of multiple queries on the same column.
     seen_filter_column_names = set()
 
     for filter_expression in match_statement_list:
         
+        if not isinstance( filter_expression, str ) or len( filter_expression ) == 0:
+            raise RuntimeError( f"Match parameters must be nonempty filter strings: you specified '{filter_expression}' (from match list {match_statement_list}), which is not." )
+
         #############################################################################################################################
         # Enforce the simplified cdapython query syntax as described in the docs, but quietly allow synonyms if received. Map them
         # first back to the canonical operator in the simplified query syntax, then validate, then normalize for API request syntax
@@ -196,7 +166,6 @@ def validate_and_transform_match_filter_list( cached_column_metadata, match_stat
 
         # Take care of two-word operators first: downstream, unmodified, they break simplifying assumptions
         # about filter string tokenization that should safe to make given the spec of the cdapython query syntax.
-
         if re.search( r'^(\S+)\s+IS\s+NOT\s+(\S.*)$', filter_expression, flags=re.IGNORECASE ) is not None:
             filter_expression = re.sub( r'^(\S+)\s+IS\s+NOT\s+(\S.*)$', r'\1 != \2', filter_expression, flags=re.IGNORECASE )
 
@@ -204,31 +173,45 @@ def validate_and_transform_match_filter_list( cached_column_metadata, match_stat
             filter_expression = re.sub( r'^(\S+)\s+NOT\s+LIKE\s+(\S.*)$', r'\1 != \2', filter_expression, flags=re.IGNORECASE )
 
         # Normalize the rest of the known operators (used for null and fuzzy matches) to conform to cdapython query syntax.
-
         elif re.search( r'^(\S+)\s+IS\s+(\S.*)$', filter_expression, flags=re.IGNORECASE ) is not None:
             filter_expression = re.sub( r'^(\S+)\s+IS\s+(\S.*)$', r'\1 = \2', filter_expression, flags=re.IGNORECASE )
 
         elif re.search( r'^(\S+)\s+LIKE\s+(\S.*)$', filter_expression, flags=re.IGNORECASE ) is not None:
             filter_expression = re.sub( r'^(\S+)\s+LIKE\s+(\S.*)$', r'\1 = \2', filter_expression, flags=re.IGNORECASE )
 
-        #############################################################################################################################
-        # Validate minimal filter string format: <non-whitespace string (column name)><whitespace><non-whitespace string (operator)><whitespace><non-whitespace string (beginning of value to match)><any mix of whitespace and non-whitespace characters (end of value to match)>
+        # Handle ternary comparisons and mark matching filters as such.
+        filter_is_ternary = False
+        filter_column_name = ''
+        match_result = re.search( r'^(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S.*)$', filter_expression )
+        if match_result is not None:
+            left_numeric = match_result.group(1)
+            left_operator = match_result.group(2)
+            column_name = match_result.group(3)
+            right_operator = match_result.group(4)
+            right_numeric = match_result.group(5)
+            if re.search( r'^[-+]?\d+(\.\d+)?$', left_numeric ) is not None and re.search( r'^[-+]?\d+(\.\d+)?$', right_numeric ) is not None and \
+                left_operator in comparison_operators and right_operator in comparison_operators:
+                # This is a numeric comparison of the type we seek.
+                is_ternary = True
+                filter_column_name = column_name.lower()
 
-        if not isinstance( filter_expression, str ) or len( filter_expression ) == 0:
-            raise RuntimeError( f"Match parameters must be nonempty filter strings: you specified '{filter_expression}' (from match list {match_statement_list}), which is not." )
+        #############################################################################################################################
+        # Validate (non-ternary) minimal filter string format: <non-whitespace string (column name)><whitespace><non-whitespace string (operator)><whitespace><non-whitespace string (beginning of value to match)><any mix of whitespace and non-whitespace characters (end of value to match)>
 
-        if re.search( r'^\S+\s+\S+\s+\S.*$', filter_expression ) is None:
+        if not filter_is_ternary and re.search( r'^\S+\s+\S+\s+\S.*$', filter_expression ) is None:
             raise RuntimeError( f"Filter string '{filter_expression}' does not conform to 'COLUMN_NAME OP VALUE' format. See the help text for details." )
 
         #############################################################################################################################
         # Now parse the filter expression and validate COLUMN and OP tokens.
 
-        # Try to extract a column name from this filter expression. Don't be case-sensitive.
-        filter_column_name = re.sub( r'^([\S]+)\s.*', r'\1', filter_expression ).lower()
+        # Try to extract a column name from this filter expression. Don't be case-sensitive. For
+        # ternary filters, we've already extracted `filter_column_name`, above.
+        if not filter_is_ternary:
+            filter_column_name = re.sub( r'^([\S]+)\s.*', r'\1', filter_expression ).lower()
 
         # Have we seen this before (and do we care)?
         if enforce_column_uniqueness:
-            if filter_column_name not in column_names_exempt_from_uniqueness_check and filter_column_name in seen_filter_column_names:
+            if filter_column_name in seen_filter_column_names:
                 raise RuntimeError( f"Requested column '{filter_column_name}' cannot be used twice in a 'match_all' list." )
             else:
                 seen_filter_column_names.add( filter_column_name )
@@ -247,92 +230,96 @@ def validate_and_transform_match_filter_list( cached_column_metadata, match_stat
         if target_data_type not in operators_by_data_type:
             raise RuntimeError( f"Requested column '{filter_column_name}' is of unknown data_type '{target_data_type}': cannot continue, please contact the CDA devs with a description of this event." )
 
-        # See what the operator is.
-        filter_operator = re.sub( r'^\S+\s+(\S+)\s.*', r'\1', filter_expression )
+        normalized_filter_expression = filter_expression
 
-        # Be kind to computer scientists.
-        if filter_operator == '==':
-            filter_operator = '='
+        if not filter_is_ternary:
+            
+            # See what the operator is.
+            filter_operator = re.sub( r'^\S+\s+(\S+)\s.*', r'\1', filter_expression )
 
-        # Make sure the operator specified is allowed for the data type of the column being filtered.
-        if filter_operator not in operators_by_data_type[target_data_type]:
-            raise RuntimeError( f"Operator '{filter_operator}' is not usable for values of type '{target_data_type}'." )
+            # Be kind to computer scientists.
+            if filter_operator == '==':
+                filter_operator = '='
 
-        # Extract the filter value/pattern.
-        filter_value = re.sub( r'^\S+\s+\S+\s+(\S.*)$', r'\1', filter_expression )
+            # Make sure the operator specified is allowed for the data type of the column being filtered.
+            if filter_operator not in operators_by_data_type[target_data_type]:
+                raise RuntimeError( f"Operator '{filter_operator}' is not usable for values of type '{target_data_type}'." )
 
-        # We said quotes weren't required for string values. Doesn't technically mean they can't be used. Remove them.
-        filter_value = re.sub( r'''^['"]*(.*)['"]*$''', r'\1', filter_value)
+            # Extract the filter value/pattern.
+            filter_value = re.sub( r'^\S+\s+\S+\s+(\S.*)$', r'\1', filter_expression )
 
-        #############################################################################################################################
-        # Validate VALUE types and process wildcards.
+            # We said quotes weren't required for string values. Doesn't technically mean they can't be used. Remove them.
+            filter_value = re.sub( r'''^['"]*(.*)['"]*$''', r'\1', filter_value)
 
-        # Ignore leading and trailing whitespace unless we're dealing with strings.
+            #############################################################################################################################
+            # Validate VALUE types and process wildcards.
 
-        if target_data_type != 'text':
-            filter_value = filter_value.strip()
+            # Ignore leading and trailing whitespace unless we're dealing with strings.
 
-        if filter_value.lower() != 'null':
-            
-            if target_data_type == 'boolean':
+            if target_data_type != 'text':
+                filter_value = filter_value.strip()
+
+            if filter_value.lower() != 'null':
                 
-                # If we're supposed to be in a boolean column, make sure we've got a true/false value. Normalize recognized synonyms for valid values.
+                if target_data_type == 'boolean':
+                    
+                    # If we're supposed to be in a boolean column, make sure we've got a true/false value. Normalize recognized synonyms for valid values.
 
-                filter_value = filter_value.lower()
+                    filter_value = filter_value.lower()
 
-                if filter_value not in boolean_alias:
-                    raise RuntimeError( f"Requested column {filter_column_name} has data type 'boolean', requiring a true/false value; you specified '{filter_value}', which is not valid." )
-                else:
-                    filter_value = boolean_alias[filter_value]
+                    if filter_value not in boolean_alias:
+                        raise RuntimeError( f"Requested column {filter_column_name} has data type 'boolean', requiring a true/false value; you specified '{filter_value}', which is not valid." )
+                    else:
+                        filter_value = boolean_alias[filter_value]
 
-            elif target_data_type in [ 'bigint', 'integer', 'numeric' ]:
-                
-                # If we're supposed to be in a numeric column, make sure we've got a number.
+                elif target_data_type in [ 'bigint', 'integer', 'numeric' ]:
+                    
+                    # If we're supposed to be in a numeric column, make sure we've got a number.
 
-                if re.search( r'^[-+]?\d+(\.\d+)?$', filter_value ) is None:
-                    raise RuntimeError( f"Requested column {filter_column_name} has data type '{target_data_type}', requiring a number value; you specified '{filter_value}', which is not." )
+                    if re.search( r'^[-+]?\d+(\.\d+)?$', filter_value ) is None:
+                        raise RuntimeError( f"Requested column {filter_column_name} has data type '{target_data_type}', requiring a number value; you specified '{filter_value}', which is not." )
 
-            elif target_data_type == 'text':
-                
-                # Check for wildcards: if found, adjust operator and
-                # wildcard syntax to match API expectations on incoming queries.
+                elif target_data_type == 'text':
+                    
+                    # Check for wildcards: if found, adjust operator and
+                    # wildcard syntax to match API expectations on incoming queries.
 
-                original_filter_value = filter_value
+                    original_filter_value = filter_value
 
-                if re.search( r'^\*', filter_value ) is not None or re.search( r'\*$', filter_value ) is not None:
-                    
-                    # API expects lowercase operators.
-                    if filter_operator == '!=':
-                        filter_operator = 'not like'
-                    else:
-                        filter_operator = 'like'
+                    if re.search( r'^\*', filter_value ) is not None or re.search( r'\*$', filter_value ) is not None:
+                        
+                        # API expects lowercase operators.
+                        if filter_operator == '!=':
+                            filter_operator = 'not like'
+                        else:
+                            filter_operator = 'like'
 
-                if re.search(r'.\*.', filter_value) is not None:
-                    raise RuntimeError( f"Wildcards (*) are only allowed at the ends of string values; string '{original_filter_value}' is noncompliant (it has one in the middle). Please fix." )
+                    if re.search(r'.\*.', filter_value) is not None:
+                        raise RuntimeError( f"Wildcards (*) are only allowed at the ends of string values; string '{original_filter_value}' is noncompliant (it has one in the middle). Please fix." )
 
-                # API expects percent signs.
-                filter_value = re.sub( r'\*', r'%', filter_value )
+                    # API expects percent signs.
+                    filter_value = re.sub( r'\*', r'%', filter_value )
 
-                # API needs strings quoted. Minimal replication case: match a string that contains only numbers. Need to distinguish from integer input.
-                filter_value = f"'{filter_value}'"
+                    # API needs strings quoted. Minimal replication case: match a string that contains only numbers. Need to distinguish from integer input.
+                    filter_value = f"'{filter_value}'"
 
-            else:
+                else:
 
-                # Just to be safe. Types change.
-                raise RuntimeError( f"Unanticipated data_type '{target_data_type}' encountered for filter-target column '{filter_column_name}'; cannot continue. Please report this event to CDA developers." )
+                    # Just to be safe. Types change.
+                    raise RuntimeError( f"Unanticipated data_type '{target_data_type}' encountered for filter-target column '{filter_column_name}'; cannot continue. Please report this event to CDA developers." )
 
-        else:
-            
-            if filter_operator == '=':
-                filter_operator = 'is'
-            elif filter_operator == '!=':
-                filter_operator = 'is not'
             else:
-                raise RuntimeError( f"Unexpected operator encountered for NULL: '{filter_operator}' (from '{filter_expression}') -- please use = or != instead." )
+                
+                if filter_operator == '=':
+                    filter_operator = 'is'
+                elif filter_operator == '!=':
+                    filter_operator = 'is not'
+                else:
+                    raise RuntimeError( f"Unexpected operator encountered for NULL: '{filter_operator}' (from '{filter_expression}') -- please use = or != instead." )
 
-            filter_value = 'null'
+                filter_value = 'null'
 
-        normalized_filter_expression = filter_column_name + ' ' + filter_operator + ' ' + filter_value
+            normalized_filter_expression = filter_column_name + ' ' + filter_operator + ' ' + filter_value
 
         normalized_match_statement_list.append( normalized_filter_expression )
 

{cdapython-2.0.2.dist-info → cdapython-2.0.4.dist-info}/METADATA

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: cdapython
-Version: 2.0.2
+Version: 2.0.4
 Summary: NCI CRDC CDA front-end user interface library
+License-File: LICENSE
 Requires-Python: >=3.9,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
@@ -9,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: cda-client (>=2.0.0)
 Requires-Dist: pandas (>=2.2.3)
 Requires-Dist: pyyaml (>=6.0.0)

cdapython-2.0.4.dist-info/RECORD

@@ -0,0 +1,13 @@
+cdapython/__init__.py,sha256=5XapTJOqQ9IfFcO4UrM09teNP_xYkTR_bQTRww6e3Wk,575
+cdapython/application_utilities.py,sha256=oD8LA9N2cM8gnTx353IdEgjtcHiI1LSlKQgUtKXtANM,1615
+cdapython/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cdapython/config/logger_default_config.yml,sha256=j4kaJk0w4-xiOyCl5Ml0DhWnK6dAWy33UecLsl1vI_w,434
+cdapython/discover.py,sha256=o15pbyPE9x0u3jf2phT-y0V2ZyppZUJWkuUb4qLpaiQ,60343
+cdapython/get_data.py,sha256=kDNxe5HhH7wou_nPngZQeDOOsU-cSywMPGNYLli1KVA,57826
+cdapython/logging_wrappers.py,sha256=SsgKrLh9y6RR-iAiMAm0Is9fGjLKQZ8BckA1MBCCLig,6885
+cdapython/summarize.py,sha256=ACwf5uuuKBjtWKGwfczR6DPIYxAw_L6xM1YKDW_DXY4,90566
+cdapython/validation.py,sha256=rVKdfEiqk0iiIx0HK7YY2vqK92jnCybrv_i3t_PUCnI,34043
+cdapython-2.0.4.dist-info/METADATA,sha256=FEEMFnYI20iw00ys3RsUYj1fcyoKs4gkt-0oL80SiYc,764
+cdapython-2.0.4.dist-info/WHEEL,sha256=M5asmiAlL6HEcOq52Yi5mmk9KmTVjY2RDPtO4p9DMrc,88
+cdapython-2.0.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+cdapython-2.0.4.dist-info/RECORD,,

{cdapython-2.0.2.dist-info → cdapython-2.0.4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: poetry-core 2.2.0
 Root-Is-Purelib: true
 Tag: py3-none-any

cdapython-2.0.2.dist-info/RECORD

@@ -1,13 +0,0 @@
-cdapython/__init__.py,sha256=5XapTJOqQ9IfFcO4UrM09teNP_xYkTR_bQTRww6e3Wk,575
-cdapython/application_utilities.py,sha256=oD8LA9N2cM8gnTx353IdEgjtcHiI1LSlKQgUtKXtANM,1615
-cdapython/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cdapython/config/logger_default_config.yml,sha256=j4kaJk0w4-xiOyCl5Ml0DhWnK6dAWy33UecLsl1vI_w,434
-cdapython/discover.py,sha256=o15pbyPE9x0u3jf2phT-y0V2ZyppZUJWkuUb4qLpaiQ,60343
-cdapython/get_data.py,sha256=vuiqpY9BQf7gSSk52ls9-qsOo5alkm1NTj55qXr8mx4,57965
-cdapython/logging_wrappers.py,sha256=SsgKrLh9y6RR-iAiMAm0Is9fGjLKQZ8BckA1MBCCLig,6885
-cdapython/summarize.py,sha256=Zpq96HpZr4wn4NVMaYfKMTWi8BQh59fpsp5rzVjW_TQ,90705
-cdapython/validation.py,sha256=Y9n440pmyFt5rc4lxKNgSRIhbgF6IQD6Xq8eB8LCjbA,35143
-cdapython-2.0.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-cdapython-2.0.2.dist-info/METADATA,sha256=Ejc_tcIjBeBYnVbznY4sZ1hzYgoYr9QnS4oVZutVeK0,691
-cdapython-2.0.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-cdapython-2.0.2.dist-info/RECORD,,