fhirpathpy 2.2.0__tar.gz → 2.2.2__tar.gz

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fhirpathpy
-Version: 2.2.0
+Version: 2.2.2
 Summary: FHIRPath implementation in Python
 Keywords: fhir,fhirpath
 Author-email: "beda.software" <fhirpath@beda.software>
@@ -16,6 +16,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
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/fhirpathpy/__init__.py

@@ -10,7 +10,7 @@ from fhirpathpy.engine.util import arraify, get_data, process_user_invocation_ta
 from fhirpathpy.parser import parse
 
 __title__ = "fhirpathpy"
-__version__ = "2.2.0"
+__version__ = "2.2.2"
 __author__ = "beda.software"
 __license__ = "MIT"
 __copyright__ = "Copyright 2026 beda.software"

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/fhirpathpy/engine/__init__.py

@@ -1,11 +1,12 @@
 import json
 import numbers
-import fhirpathpy.engine.util as util
-from fhirpathpy.engine.nodes import TypeInfo
+
+from fhirpathpy.engine import util
 from fhirpathpy.engine.evaluators import evaluators
 from fhirpathpy.engine.invocations import (
     invocation_registry as base_invocation_registry,
 )
+from fhirpathpy.engine.nodes import TypeInfo
 
 
 def check_integer_param(val):
@@ -63,6 +64,14 @@ def doInvoke(ctx, fn_name, data, raw_params):
     if "nullable_input" in invocation and util.is_nullable(data):
         return []
 
+    if "variadic" in invocation:
+        tp = invocation["variadic"]
+        raw_params_list = raw_params if isinstance(raw_params, list) else []
+        thisValue = ctx["$this"] if "$this" in ctx else ctx["dataRoot"]
+        params = [make_param(ctx, thisValue, tp, pr) for pr in raw_params_list]
+        res = invocation["fn"](ctx, util.arraify(data), *params)
+        return util.arraify(res)
+
     if "arity" not in invocation:
         if raw_params is None or util.is_empty(raw_params):
             res = invocation["fn"](ctx, util.arraify(data))
@@ -160,10 +169,7 @@ def make_param(ctx, parentData, node_type, param):
 
     if len(res) > 1:
         raise Exception(
-            "Unexpected collection"
-            + json.dumps(res)
-            + "; expected singleton of type "
-            + node_type
+            "Unexpected collection" + json.dumps(res) + "; expected singleton of type " + node_type
         )
 
     if len(res) == 0:

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/fhirpathpy/engine/evaluators/__init__.py

@@ -1,12 +1,11 @@
+import json
+import re
 from collections import abc
 from decimal import Decimal
 from functools import reduce
 
-import re
-import json
-import fhirpathpy.engine as engine
-import fhirpathpy.engine.util as util
-import fhirpathpy.engine.nodes as nodes
+from fhirpathpy import engine
+from fhirpathpy.engine import nodes, util
 
 
 def boolean_literal(ctx, parentData, node):
@@ -71,7 +70,7 @@ def alias_op_expression(mapFn):
     def func(ctx, parentData, node):
         op = node["terminalNodeText"][0]
 
-        if not op in mapFn:
+        if op not in mapFn:
             raise Exception("Do not know how to alias " + op + " by " + json.dumps(mapFn))
 
         alias = mapFn[op]
@@ -107,7 +106,7 @@ def external_constant_term(ctx, parent_data, node):
     varName = identifier(ctx, parent_data, ext_identifier)[0].replace("`", "")
 
     if varName not in ctx["vars"]:
-        raise ValueError(f'Attempting to access an undefined environment variable: {varName}')
+        raise ValueError(f"Attempting to access an undefined environment variable: {varName}")
 
     value = ctx["vars"][varName]
 
@@ -174,7 +173,9 @@ def create_reduce_member_invocation(model, key):
     def func(acc, res):
         res = nodes.ResourceNode.create_node(res)
         childPath = f"{res.path}.{key}" if res.path else f"_.{key}"
-        fullPath = f"{res.propName}.{key}" if res.propName else childPath # The full path to the node (weill evenutally be) e.g. Patient.name[0].given
+        fullPath = (
+            f"{res.propName}.{key}" if res.propName else childPath
+        )  # The full path to the node (weill evenutally be) e.g. Patient.name[0].given
         fullPath = fullPath.replace("_", "")
 
         actualTypes = None
@@ -202,9 +203,8 @@ def create_reduce_member_invocation(model, key):
             toAdd_ = res.data.get(f"_{key}")
             if key == "extension":
                 childPath = "Extension"
-        else:
-            if key == "length":
-                toAdd = len(res.data)
+        elif key == "length":
+            toAdd = len(res.data)
 
         childPath = (
             model["path2Type"].get(childPath, childPath)
@@ -214,13 +214,23 @@ def create_reduce_member_invocation(model, key):
 
         if util.is_some(toAdd):
             if isinstance(toAdd, list):
-                mapped = [nodes.ResourceNode.create_node(x, childPath, propName=f"{fullPath}[{i}]", index=i) for i, x in enumerate(toAdd)]
+                mapped = [
+                    nodes.ResourceNode.create_node(
+                        x, childPath, propName=f"{fullPath}[{i}]", index=i
+                    )
+                    for i, x in enumerate(toAdd)
+                ]
                 acc = acc + mapped
             else:
                 acc.append(nodes.ResourceNode.create_node(toAdd, childPath, propName=fullPath))
         if util.is_some(toAdd_):
             if isinstance(toAdd_, list):
-                mapped = [nodes.ResourceNode.create_node(x, childPath, propName=f"{fullPath}[{i}]", index=i) for i, x in enumerate(toAdd_)]
+                mapped = [
+                    nodes.ResourceNode.create_node(
+                        x, childPath, propName=f"{fullPath}[{i}]", index=i
+                    )
+                    for i, x in enumerate(toAdd_)
+                ]
                 acc = acc + mapped
             else:
                 acc.append(nodes.ResourceNode.create_node(toAdd_, childPath, propName=fullPath))

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/fhirpathpy/engine/invocations/__init__.py

@@ -1,19 +1,21 @@
 from decimal import Decimal
 
-import fhirpathpy.engine.invocations.collections as collections
-import fhirpathpy.engine.invocations.existence as existence
-import fhirpathpy.engine.invocations.filtering as filtering
-import fhirpathpy.engine.invocations.subsetting as subsetting
-import fhirpathpy.engine.invocations.strings as strings
-import fhirpathpy.engine.invocations.navigation as navigation
-import fhirpathpy.engine.invocations.combining as combining
-import fhirpathpy.engine.invocations.math as math
-import fhirpathpy.engine.invocations.misc as misc
-import fhirpathpy.engine.invocations.equality as equality
-import fhirpathpy.engine.invocations.logic as logic
-import fhirpathpy.engine.invocations.datetime as datetime
-import fhirpathpy.engine.invocations.types as types
-import fhirpathpy.engine.invocations.aggregate as aggregate
+from fhirpathpy.engine.invocations import (
+    aggregate,
+    collections,
+    combining,
+    datetime,
+    equality,
+    existence,
+    filtering,
+    logic,
+    math,
+    misc,
+    navigation,
+    strings,
+    subsetting,
+    types,
+)
 from fhirpathpy.engine.nodes import FP_DateTime, FP_Quantity, FP_Time
 
 invocation_registry = {
@@ -21,8 +23,8 @@ invocation_registry = {
     "not": {"fn": existence.not_fn},
     "exists": {"fn": existence.exists_macro, "arity": {0: [], 1: ["Expr"]}},
     "all": {"fn": existence.all_macro, "arity": {1: ["Expr"]}},
-    "union": {"fn": combining.union_op,   "arity": {1: ["AnyAtRoot"]}},
-    "exclude": {"fn": combining.exclude_fn,   "arity": {1: ["AnyAtRoot"]}},
+    "union": {"fn": combining.union_op, "arity": {1: ["AnyAtRoot"]}},
+    "exclude": {"fn": combining.exclude_fn, "arity": {1: ["AnyAtRoot"]}},
     "allTrue": {"fn": existence.all_true_fn},
     "anyTrue": {"fn": existence.any_true_fn},
     "allFalse": {"fn": existence.all_false_fn},
@@ -48,6 +50,7 @@ invocation_registry = {
     "skip": {"fn": filtering.skip_fn, "arity": {1: ["Integer"]}},
     "intersect": {"fn": subsetting.intersect_fn, "arity": {1: ["AnyAtRoot"]}},
     "combine": {"fn": combining.combine_fn, "arity": {1: ["AnyAtRoot"]}},
+    "coalesce": {"fn": combining.coalesce_fn, "variadic": "Expr"},
     "iif": {"fn": misc.iif_macro, "arity": {2: ["Expr", "Expr"], 3: ["Expr", "Expr", "Expr"]}},
     "trace": {"fn": misc.trace_fn, "arity": {0: [], 1: ["String"]}},
     "toInteger": {"fn": misc.to_integer},
@@ -109,8 +112,8 @@ invocation_registry = {
     ">=": {"fn": equality.gte, "arity": {2: ["Any", "Any"]}, "nullable": True},
     "containsOp": {"fn": collections.contains, "arity": {2: ["Any", "Any"]}},
     "inOp": {"fn": collections.inn, "arity": {2: ["Any", "Any"]}},
-    "isOp": {"fn": types.is_fn,  "arity": {2: ["Any", "TypeSpecifier"]}},
-    "asOp": {"fn": types.as_fn,  "arity": {2: ["Any", "TypeSpecifier"]}},
+    "isOp": {"fn": types.is_fn, "arity": {2: ["Any", "TypeSpecifier"]}},
+    "asOp": {"fn": types.as_fn, "arity": {2: ["Any", "TypeSpecifier"]}},
     "&": {"fn": math.amp, "arity": {2: ["String", "String"]}},
     "+": {"fn": math.plus, "arity": {2: ["Any", "Any"]}, "nullable": True},
     "-": {"fn": math.minus, "arity": {2: ["Any", "Any"]}, "nullable": True},
@@ -127,10 +130,10 @@ invocation_registry = {
     "min": {"fn": aggregate.min_fn},
     "max": {"fn": aggregate.max_fn},
     "aggregate": {"fn": aggregate.aggregate_macro, "arity": {1: ["Expr"], 2: ["Expr", "Any"]}},
-    "convertsToBoolean": {"fn": misc.create_converts_to_fn(misc.to_boolean, 'bool')},
-    "convertsToInteger": {"fn": misc.create_converts_to_fn(misc.to_integer, 'int')},
+    "convertsToBoolean": {"fn": misc.create_converts_to_fn(misc.to_boolean, "bool")},
+    "convertsToInteger": {"fn": misc.create_converts_to_fn(misc.to_integer, "int")},
     "convertsToDecimal": {"fn": misc.create_converts_to_fn(misc.to_decimal, Decimal)},
-    "convertsToString": {"fn": misc.create_converts_to_fn(misc.to_string, 'str')},
+    "convertsToString": {"fn": misc.create_converts_to_fn(misc.to_string, "str")},
     "convertsToDate": {"fn": misc.create_converts_to_fn(misc.to_date, FP_DateTime)},
     "convertsToDateTime": {"fn": misc.create_converts_to_fn(misc.to_date_time, FP_DateTime)},
     "convertsToTime": {"fn": misc.create_converts_to_fn(misc.to_time, FP_Time)},

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/fhirpathpy/engine/invocations/collections.py

@@ -1,4 +1,4 @@
-""" 
+"""
 This file holds code to hande the FHIRPath Math functions.
 """
 

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/fhirpathpy/engine/invocations/combining.py

@@ -1,4 +1,5 @@
-import fhirpathpy.engine.invocations.existence as existence
+from fhirpathpy.engine import util
+from fhirpathpy.engine.invocations import existence
 
 """
 This file holds code to hande the FHIRPath Combining functions
@@ -15,3 +16,11 @@ def combine_fn(ctx, coll1, coll2):
 
 def exclude_fn(ctx, coll1, coll2):
     return [element for element in coll1 if element not in coll2]
+
+
+def coalesce_fn(ctx, data, *exprs):
+    for expr in exprs:
+        result = expr(data)
+        if not util.is_empty(result):
+            return result
+    return []

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/fhirpathpy/engine/invocations/equality.py

@@ -1,8 +1,8 @@
+import json
 from collections import abc
 from decimal import Decimal
-import json
-import fhirpathpy.engine.util as util
-import fhirpathpy.engine.nodes as nodes
+
+from fhirpathpy.engine import nodes, util
 
 """
 This file holds code to hande the FHIRPath Math functions.
@@ -81,7 +81,7 @@ def equivalence(ctx, x, y):
     if isinstance(x_val, nodes.FP_Quantity) and isinstance(y_val, nodes.FP_Quantity):
         return x_val.deep_equal(y_val)
 
-    if isinstance(a, (abc.Mapping, list)) and isinstance(b, (abc.Mapping, list)):
+    if isinstance(a, abc.Mapping | list) and isinstance(b, abc.Mapping | list):
 
         def deep_equal(a, b):
             if isinstance(a, abc.Mapping) and isinstance(b, abc.Mapping):
@@ -94,7 +94,7 @@ def equivalence(ctx, x, y):
                 )
             elif isinstance(a, str) and isinstance(b, str):
                 return normalize_string(a) == normalize_string(b)
-            elif isinstance(a, (int, float)) and isinstance(b, (int, float)):
+            elif isinstance(a, int | float) and isinstance(b, int | float):
                 return abs(a - b) < 0.5
             else:
                 return a == b
@@ -190,12 +190,11 @@ def typecheck(a, b):
     if lClass != rClass and not areNumbers:
         d = None
 
-        # TODO refactor
-        if lClass == str and (rClass == nodes.FP_DateTime or rClass == nodes.FP_Time):
+        if lClass is str and (rClass in (nodes.FP_DateTime, nodes.FP_Time)):
             d = nodes.FP_DateTime(a) or nodes.FP_Time(a)
             if d is not None:
                 rtn = [d, b]
-        elif rClass == str and (lClass == nodes.FP_DateTime or lClass == nodes.FP_Time):
+        elif rClass is str and (lClass in (nodes.FP_DateTime, nodes.FP_Time)):
             d = nodes.FP_DateTime(b) or nodes.FP_Time(b)
             if d is not None:
                 rtn = [a, d]

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/fhirpathpy/engine/invocations/existence.py

@@ -1,10 +1,7 @@
 from decimal import Decimal
-from fhirpathpy.engine.invocations import misc
-from fhirpathpy.engine.invocations.misc import to_boolean
-import fhirpathpy.engine.util as util
-import fhirpathpy.engine.nodes as nodes
-import fhirpathpy.engine.invocations.filtering as filtering
 
+from fhirpathpy.engine import nodes, util
+from fhirpathpy.engine.invocations import filtering, misc
 
 """
 This file holds code to hande the FHIRPath Existence functions
@@ -54,7 +51,7 @@ def all_macro(ctx, colls, expr):
 
 def extract_boolean_value(data):
     value = util.get_data(data)
-    if type(value) != bool:
+    if type(value) is not bool:
         raise Exception("Found type '" + type(data) + "' but was expecting bool")
     return value
 

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/fhirpathpy/engine/invocations/filtering.py

@@ -1,8 +1,6 @@
 from collections import abc
-from decimal import Decimal
-import numbers
-import fhirpathpy.engine.util as util
-import fhirpathpy.engine.nodes as nodes
+
+from fhirpathpy.engine import nodes, util
 
 # Contains the FHIRPath Filtering and Projection functions.
 # (Section 5.2 of the FHIRPath 1.0.0 specification).
@@ -54,18 +52,18 @@ def repeat_macro(ctx, data, expr):
     res = []
     items = data
 
-    next = None
+    next_item = None
     lres = None
 
     uniq = set()
 
     while len(items) != 0:
-        next = items[0]
+        next_item = items[0]
         items = items[1:]
-        lres = [l for l in expr(next) if l not in uniq]
+        lres = [elem for elem in expr(next_item) if elem not in uniq]
         if len(lres) > 0:
-            for l in lres:
-                uniq.add(l)
+            for elem in lres:
+                uniq.add(elem)
             res = res + lres
             items = items + lres
 

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/fhirpathpy/engine/invocations/logic.py

@@ -1,13 +1,13 @@
 def or_op(ctx, a, b):
     if isinstance(b, list):
-        if a == True:
+        if a is True:
             return True
-        if a == False:
+        if a is False:
             return []
         if isinstance(a, list):
             return []
     if isinstance(a, list):
-        if b == True:
+        if b is True:
             return True
         return []
 
@@ -16,15 +16,15 @@ def or_op(ctx, a, b):
 
 def and_op(ctx, a, b):
     if isinstance(b, list):
-        if a == True:
+        if a is True:
             return []
-        if a == False:
+        if a is False:
             return False
         if isinstance(a, list):
             return []
 
     if isinstance(a, list):
-        if b == True:
+        if b is True:
             return []
         return False
 
@@ -42,19 +42,19 @@ def xor_op(ctx, a, b):
 
 def implies_op(ctx, a, b):
     if isinstance(b, list):
-        if a == True:
+        if a is True:
             return []
-        if a == False:
+        if a is False:
             return True
         if isinstance(a, list):
             return []
 
     if isinstance(a, list):
-        if b == True:
+        if b is True:
             return True
         return []
 
-    if a == False:
+    if a is False:
         return True
 
     return a and b

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/fhirpathpy/engine/invocations/math.py

@@ -1,7 +1,7 @@
 from decimal import Decimal
+
+from fhirpathpy.engine import nodes, util
 from fhirpathpy.engine.invocations.equality import remove_duplicate_extension
-import fhirpathpy.engine.util as util
-import fhirpathpy.engine.nodes as nodes
 
 """
 Adds the math functions to the given FHIRPath engine.

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/fhirpathpy/engine/invocations/misc.py

@@ -1,8 +1,7 @@
 import re
 from decimal import Decimal
 
-import fhirpathpy.engine.util as util
-import fhirpathpy.engine.nodes as nodes
+from fhirpathpy.engine import nodes, util
 
 # This file holds code to hande the FHIRPath Existence functions (5.1 in the
 # specification).
@@ -36,10 +35,10 @@ def to_integer(ctx, coll):
 
     value = util.get_data(coll[0])
 
-    if value == False:
+    if value is False:
         return 0
 
-    if value == True:
+    if value is True:
         return 1
 
     if util.is_number(value):
@@ -72,7 +71,7 @@ def to_quantity(ctx, coll, to_unit=None):
         v = util.val_data_converted(coll[0])
         quantity_regex_res = None
 
-        if isinstance(v, (int, Decimal)):
+        if isinstance(v, int | Decimal):
             result = nodes.FP_Quantity(v, "'1'")
         elif isinstance(v, nodes.FP_Quantity):
             result = v
@@ -130,62 +129,63 @@ def to_string(ctx, coll):
 
 def to_date_time(ctx, coll):
     ln = len(coll)
-    rtn = []
     if ln > 1:
         raise Exception("to_date_time called for a collection of length " + str(ln))
 
-    if ln == 1:
-        value = util.get_data(coll[0])
+    if ln != 1:
+        return []
 
-        dateTimeObject = nodes.FP_DateTime(value)
+    value = util.get_data(coll[0])
+    dateTimeObject = nodes.FP_DateTime(value)
 
-        if dateTimeObject:
-            rtn.append(dateTimeObject)
+    if not dateTimeObject:
+        return []
 
-    return util.get_data(rtn[0])
+    return util.get_data(dateTimeObject)
 
 
 def to_time(ctx, coll):
     ln = len(coll)
-    rtn = []
     if ln > 1:
         raise Exception("to_time called for a collection of length " + str(ln))
 
-    if ln == 1:
-        value = util.get_data(coll[0])
+    if ln != 1:
+        return []
 
-        timeObject = nodes.FP_Time(value)
+    value = util.get_data(coll[0])
+    timeObject = nodes.FP_Time(value)
 
-        if timeObject:
-            rtn.append(timeObject)
+    if not timeObject:
+        return []
 
-    return util.get_data(rtn[0])
+    return util.get_data(timeObject)
 
 
 def to_date(ctx, coll):
     ln = len(coll)
-    rtn = []
-
     if ln > 1:
         raise Exception("to_date called for a collection of length " + str(ln))
 
-    if ln == 1:
-        value = util.get_data(coll[0])
+    if ln != 1:
+        return []
 
-        dateObject = nodes.FP_DateTime(value)
+    value = util.get_data(coll[0])
+    dateObject = nodes.FP_DateTime(value)
 
-        if dateObject:
-            rtn.append(dateObject)
+    if not dateObject:
+        return []
 
-    return util.get_data(rtn[0])
+    return util.get_data(dateObject)
 
 
 def create_converts_to_fn(to_function, _type):
     if isinstance(_type, str):
+
         def in_function(ctx, coll):
             if len(coll) != 1:
                 return []
             return type(to_function(ctx, coll)).__name__ == _type
+
         return in_function
 
     def in_function(ctx, coll):
@@ -198,8 +198,8 @@ def create_converts_to_fn(to_function, _type):
 
 
 def to_boolean(ctx, coll):
-    true_strings = ['true', 't', 'yes', 'y', '1', '1.0']
-    false_strings = ['false', 'f', 'no', 'n', '0', '0.0']
+    true_strings = ["true", "t", "yes", "y", "1", "1.0"]
+    false_strings = ["false", "f", "no", "n", "0", "0.0"]
 
     if len(coll) != 1:
         return []
@@ -209,10 +209,10 @@ def to_boolean(ctx, coll):
 
     if var_type == "bool":
         return val
-    elif var_type == "int" or var_type == "float":
-        if val == 1 or val == 1.0:
+    elif var_type in ("int", "float"):
+        if val in (1, 1.0):
             return True
-        elif val == 0 or val == 0.0:
+        elif val in (0, 0.0):
             return False
     elif var_type == "str":
         lower_case_var = val.lower()
@@ -231,25 +231,28 @@ def boolean_singleton(coll):
     elif len(coll) == 1:
         return True
 
+
 def string_singleton(coll):
     d = util.get_data(coll[0])
     if isinstance(d, str):
         return d
 
+
 singleton_eval_by_type = {
     "Boolean": boolean_singleton,
     "String": string_singleton,
 }
 
+
 def singleton(coll, type):
     if len(coll) > 1:
-        raise Exception("Unexpected collection {coll}; expected singleton of type {type}".format(coll=coll, type=type))
+        raise Exception(f"Unexpected collection {coll}; expected singleton of type {type}")
     elif len(coll) == 0:
         return []
     to_singleton = singleton_eval_by_type[type]
     if to_singleton:
         val = to_singleton(coll)
-        if (val is not None):
+        if val is not None:
             return val
-        raise Exception("Expected {type}, but got: {coll}".format(type=type.lower(), coll=coll))
-    raise Exception("Not supported type {}".format(type))
+        raise Exception(f"Expected {type.lower()}, but got: {coll}")
+    raise Exception(f"Not supported type {type}")

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/fhirpathpy/engine/invocations/navigation.py

@@ -1,7 +1,7 @@
 from collections import abc
 from functools import reduce
-import fhirpathpy.engine.util as util
-import fhirpathpy.engine.nodes as nodes
+
+from fhirpathpy.engine import nodes, util
 
 create_node = nodes.ResourceNode.create_node
 
@@ -30,7 +30,9 @@ def create_reduce_children(ctx, exclude_primitive_extensions):
                 if res.path is not None:
                     childPath = res.path + "." + prop
 
-                fullPath = f"{res.propName}.{prop}" if res.propName else childPath # The full path to the node (weill evenutally be) e.g. Patient.name[0].given
+                fullPath = (
+                    f"{res.propName}.{prop}" if res.propName else childPath
+                )  # The full path to the node (weill evenutally be) e.g. Patient.name[0].given
                 fullPath = fullPath.replace("_", "")
 
                 if prop == "extension":
@@ -52,14 +54,17 @@ def create_reduce_children(ctx, exclude_primitive_extensions):
                 # If the prop tolower ends with the type tolower
                 if prop.lower().endswith(childPath.lower()) and len(prop) > len(childPath):
                     # Check if the path is actually in the choice types
-                    altPropName = res.path + "." + prop[:-len(childPath)]
+                    altPropName = res.path + "." + prop[: -len(childPath)]
                     actualTypes = model["choiceTypePaths"].get(altPropName, [])
                     if len(actualTypes) > 0:
                         # If it is, we can use it
-                        fullPath = f"{res.propName}.{prop[:-len(childPath)]}"
+                        fullPath = f"{res.propName}.{prop[: -len(childPath)]}"
 
                 if isinstance(value, list):
-                    mapped = [create_node(n, childPath, propName=f"{fullPath}[{i}]", index=i) for i, n in enumerate(value)]
+                    mapped = [
+                        create_node(n, childPath, propName=f"{fullPath}[{i}]", index=i)
+                        for i, n in enumerate(value)
+                    ]
                     acc = acc + mapped
                 else:
                     acc.append(create_node(value, childPath, propName=fullPath))

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/fhirpathpy/engine/invocations/strings.py

@@ -1,12 +1,13 @@
 import base64
 import re
-import fhirpathpy.engine.util as util
+
+from fhirpathpy.engine import util
 
 
 def ensure_string_singleton(x):
     if len(x) == 1:
         d = util.get_data(x[0])
-        if type(d) == str:
+        if isinstance(d, str):
             return d
         raise Exception("Expected string, but got " + str(d))
 

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/fhirpathpy/engine/invocations/types.py

@@ -1,5 +1,6 @@
 from fhirpathpy.engine.nodes import TypeInfo
 
+
 def type_fn(ctx, coll):
     return [TypeInfo.from_value(value).__dict__ for value in coll]
 

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/fhirpathpy/engine/nodes.py

@@ -1,15 +1,13 @@
-from collections import abc
 import copy
-from datetime import datetime, timedelta, timezone
-from dateutil.relativedelta import relativedelta
-from dateutil import parser, tz
-from decimal import ROUND_HALF_UP, ROUND_UP, Decimal
-import math
 import json
+import math
 import re
-import time
-from typing import Optional
+from collections import abc
+from datetime import datetime, timedelta, timezone
+from decimal import ROUND_HALF_UP, ROUND_UP, Decimal
 
+from dateutil import parser, tz
+from dateutil.relativedelta import relativedelta
 
 timeRE = (
     r"^T?([0-9]{2})(?::([0-9]{2}))?(?::([0-9]{2}))?(?:\.([0-9]+))?(Z|(\+|-)[0-9]{2}(:[0-9]{2})?)?$"
@@ -258,8 +256,9 @@ class FP_Quantity(FP_Type):
                 fromUnit in FP_Quantity._m_cm_mm_conversion_factor
                 or toUnit in FP_Quantity._m_cm_mm_conversion_factor
             ):
-                from_magnitude, to_magnitude = Decimal(from_m_cm_mm_magnitude), Decimal(
-                    to_m_cm_mm_magnitude
+                from_magnitude, to_magnitude = (
+                    Decimal(from_m_cm_mm_magnitude),
+                    Decimal(to_m_cm_mm_magnitude),
                 )
             return FP_Quantity(from_magnitude * value / to_magnitude, toUnit)
 
@@ -343,7 +342,7 @@ class FP_TimeBase(FP_Type):
             2012-01 = 2011 returns false
             2012-01 ~ 2012 returns false
         """
-        if type(otherDateTime) != type(self):
+        if type(otherDateTime) is not type(self):
             return False
 
         thisdt_list = self._getMatchAsList()
@@ -355,7 +354,7 @@ class FP_TimeBase(FP_Type):
         indices_to_remove = [
             i
             for i in range(len(normalized_thisdt_list))
-            if normalized_thisdt_list[i] == normalized_otherdt_list[i] == None
+            if normalized_thisdt_list[i] is None and normalized_otherdt_list[i] is None
         ]
 
         for i in reversed(indices_to_remove):
@@ -413,7 +412,7 @@ class FP_TimeBase(FP_Type):
         ]
 
     def compare(self, otherDateTime):
-        if type(otherDateTime) != type(self):
+        if type(otherDateTime) is not type(self):
             raise TypeError
 
         thisDateTimeList = self._getMatchAsList()
@@ -424,7 +423,7 @@ class FP_TimeBase(FP_Type):
         indices_to_remove = [
             i
             for i in range(len(normalized_thisdt_list))
-            if normalized_thisdt_list[i] == normalized_otherdt_list[i] == None
+            if normalized_thisdt_list[i] is None and normalized_otherdt_list[i] is None
         ]
         for i in reversed(indices_to_remove):
             del normalized_thisdt_list[i]
@@ -598,7 +597,7 @@ class FP_Time(FP_TimeBase):
         if not re.match(timeRE, dateStr):
             return None
 
-        return super(FP_Time, cls).__new__(cls)
+        return super().__new__(cls)
 
     def __init__(self, timeStr):
         self.asStr = timeStr if isinstance(timeStr, str) else None
@@ -647,6 +646,8 @@ class FP_Time(FP_TimeBase):
             return time_str
         return self.asStr
 
+    __hash__ = None
+
     def __eq__(self, other):
         if isinstance(other, str):
             return self.getTimeMatchStr()
@@ -705,7 +706,7 @@ class FP_DateTime(FP_TimeBase):
         if not re.match(dateTimeRE, dateStr):
             return None
 
-        return super(FP_DateTime, cls).__new__(cls)
+        return super().__new__(cls)
 
     def __init__(self, dateStr):
         self.asStr = dateStr if isinstance(dateStr, str) else None
@@ -735,6 +736,8 @@ class FP_DateTime(FP_TimeBase):
             return iso_str
         return self.asStr
 
+    __hash__ = None
+
     def __eq__(self, other):
         if isinstance(other, str):
             return self.getDateTimeMatchStr()
@@ -833,8 +836,8 @@ class ResourceNode:
         self.path = path
         self.data = data
         self._data = _data
-        self.propName: Optional[str] = propName
-        self.index: Optional[int] = index
+        self.propName: str | None = propName
+        self.index: int | None = index
 
     def __eq__(self, value):
         if isinstance(value, ResourceNode):

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/fhirpathpy/engine/util.py

@@ -1,8 +1,9 @@
-from decimal import Decimal
 import json
 from collections import OrderedDict
+from decimal import Decimal
 from functools import reduce
-from fhirpathpy.engine.nodes import ResourceNode, FP_Quantity
+
+from fhirpathpy.engine.nodes import FP_Quantity, ResourceNode
 
 
 class set_paths:
@@ -13,9 +14,7 @@ class set_paths:
         self.options = options
 
     def __call__(self, resource, context=None):
-        return self.func(
-            resource, self.parsedPath, context or {}, self.model, self.options
-        )
+        return self.func(resource, self.parsedPath, context or {}, self.model, self.options)
 
 
 def get_data(value):
@@ -41,7 +40,7 @@ def parse_value(value):
 
 
 def is_number(value):
-    return isinstance(value, (int, Decimal, complex)) and not isinstance(value, bool)
+    return isinstance(value, int | Decimal | complex) and not isinstance(value, bool)
 
 
 def is_capitalized(x):
@@ -61,7 +60,9 @@ def is_nullable(x):
 
 
 def is_true(x):
-    return x == True or isinstance(x, list) and len(x) == 1 and x[0] == True
+    # Use == not is: mid-pipeline values are often ResourceNode wrappers; __eq__
+    # compares .data, while `is True` does not (see fhirpathpy 2.2.1 regression).
+    return x == True or isinstance(x, list) and len(x) == 1 and x[0] == True  # noqa: E712
 
 
 def arraify(x, instead_none=None):

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/fhirpathpy/models/__init__.py

@@ -1,8 +1,7 @@
-import os
-from collections import defaultdict
 import json
-
+import os
 import pathlib
+from collections import defaultdict
 
 current_dir = pathlib.Path(__file__).parent.resolve()
 

{fhirpathpy-2.2.0 → fhirpathpy-2.2.2}/pyproject.toml

@@ -30,6 +30,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Internet :: WWW/HTTP",
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Typing :: Typed",
@@ -50,11 +51,12 @@ Changelog = "https://github.com/beda-software/fhirpath-py/blob/master/CHANGELOG.
 target-version = "py310"
 line-length = 100
 include = ["fhirpathpy/**/*.py", "tests/**/*.py"]
+exclude = ["fhirpathpy/parser/**/*.py"]
 
 [tool.ruff.lint]
 select = ["B", "F", "I", "E", "UP", "N", "PL", "PERF"]
-# N803/N806 is not relevant for us because we use camelCase for historical reasons
-ignore = ["E501", "N803", "N806"]
+# N8* is not relevant for us because of legacy code
+ignore = ["E501", "N801", "N802", "N805", "N815", "N816", "N803", "N806", "PLR0911", "PLR0912", "PLR0915", "PLR2004", "PLW0211"]
 unfixable = ["F401"]
 
 [tool.mypy]