fhirpathpy 2.0.3__tar.gz → 2.2.0__tar.gz

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

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: fhirpathpy
-Version: 2.0.3
+Version: 2.2.0
 Summary: FHIRPath implementation in Python
 Keywords: fhir,fhirpath
 Author-email: "beda.software" <fhirpath@beda.software>
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Web Environment
@@ -12,17 +12,19 @@ Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 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: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
 License-File: LICENSE.md
 Requires-Dist: antlr4-python3-runtime~=4.10
 Requires-Dist: python-dateutil~=2.8
 Requires-Dist: pytest==7.1.1 ; extra == "test"
 Requires-Dist: pyyaml==5.4 ; extra == "test"
+Requires-Dist: pydantic==2.13.1 ; extra == "test"
 Project-URL: Changelog, https://github.com/beda-software/fhirpath-py/blob/master/CHANGELOG.md
 Project-URL: Documentation, https://github.com/beda-software/fhirpath-py#readme
 Project-URL: Homepage, https://github.com/beda-software/fhirpath-py
@@ -35,7 +37,7 @@ fhirpath.py
 [![Build Status](https://github.com/beda-software/fhirpath-py/actions/workflows/build.yaml/badge.svg)](https://github.com/beda-software/fhirpath-py/actions)
 [![codecov](https://codecov.io/gh/beda-software/fhirpath-py/branch/master/graph/badge.svg)](https://codecov.io/gh/beda-software/fhirpath-py)
 [![pypi](https://img.shields.io/pypi/v/fhirpathpy.svg)](https://pypi.org/project/fhirpathpy/)
-[![Supported Python version](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/release/python-380/)
+[![Supported Python version](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/release/python-3100/)
 
 [FHIRPath](https://www.hl7.org/fhir/fhirpath.html) implementation in Python
 

{fhirpathpy-2.0.3 → fhirpathpy-2.2.0}/README.md

@@ -4,7 +4,7 @@ fhirpath.py
 [![Build Status](https://github.com/beda-software/fhirpath-py/actions/workflows/build.yaml/badge.svg)](https://github.com/beda-software/fhirpath-py/actions)
 [![codecov](https://codecov.io/gh/beda-software/fhirpath-py/branch/master/graph/badge.svg)](https://codecov.io/gh/beda-software/fhirpath-py)
 [![pypi](https://img.shields.io/pypi/v/fhirpathpy.svg)](https://pypi.org/project/fhirpathpy/)
-[![Supported Python version](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/release/python-380/)
+[![Supported Python version](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/release/python-3100/)
 
 [FHIRPath](https://www.hl7.org/fhir/fhirpath.html) implementation in Python
 

fhirpathpy-2.2.0/fhirpathpy/__init__.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from typing import Any, Protocol, TypeVar, cast
+
+from fhirpathpy.engine import do_eval
+from fhirpathpy.engine.invocations.constants import constants
+from fhirpathpy.engine.nodes import FP_Type, ResourceNode
+from fhirpathpy.engine.util import arraify, get_data, process_user_invocation_table, set_paths
+from fhirpathpy.parser import parse
+
+__title__ = "fhirpathpy"
+__version__ = "2.2.0"
+__author__ = "beda.software"
+__license__ = "MIT"
+__copyright__ = "Copyright 2026 beda.software"
+
+# Version synonym
+VERSION = __version__
+
+ResourceType = Mapping[str, Any]
+ContextType = Mapping[str, Any] | None
+
+
+def apply_parsed_path(resource, parsedPath, context=None, model=None, options=None):
+    constants.reset()
+    dataRoot = arraify(resource)
+
+    """
+    do_eval takes a "ctx" object, and we store things in that as we parse, so we
+    need to put user-provided variable data in a sub-object, ctx['vars'].
+    Set up default standard variables, and allow override from the variables.
+    However, we'll keep our own copy of dataRoot for internal processing.
+    """
+    vars = {"context": resource, "ucum": "http://unitsofmeasure.org"}
+    vars.update(context or {})
+
+    ctx = {
+        "dataRoot": dataRoot,
+        "vars": vars,
+        "model": model,
+        "userInvocationTable": process_user_invocation_table(
+            (options or {}).get("userInvocationTable", {})
+        ),
+    }
+
+    # Add trace callback if provided in options
+    if options and "traceFn" in options:
+        ctx["traceFn"] = options["traceFn"]
+
+    node = do_eval(ctx, dataRoot, parsedPath["children"][0])
+
+    # Resolve any internal "ResourceNode" instances.  Continue to let FP_Type
+    # subclasses through.
+
+    if options and options.get("returnRawData", False):
+        if isinstance(node, list):
+            res = []
+            # Filter out intenal representation of primitive extensions
+            # even in this raw data mode (as they are not a part of the output)
+            for item in node:
+                if isinstance(item, ResourceNode):
+                    if isinstance(item.data, dict):
+                        keys = list(item.data.keys())
+                        if keys == ["extension"]:
+                            continue
+                res.append(item)
+            return res
+        return node
+
+    def visit(node):
+        data = get_data(node)
+
+        if isinstance(node, list):
+            res = []
+            for item in data:
+                # Filter out intenal representation of primitive extensions
+                i = visit(item)
+                if isinstance(i, dict):
+                    keys = list(i.keys())
+                    if keys == ["extension"]:
+                        continue
+                res.append(i)
+            return res
+
+        if isinstance(data, dict) and not isinstance(data, FP_Type):
+            for key, value in data.items():
+                data[key] = visit(value)
+
+        return data
+
+    return visit(node)
+
+
+def evaluate(
+    resource: ResourceType | list,
+    path: str | dict,
+    context: dict | None = None,
+    model: dict | None = None,
+    options: dict | None = None,
+) -> list:
+    """
+    Evaluates the "path" FHIRPath expression on the given resource, using data
+    from "context" for variables mentioned in the "path" expression.
+
+    Parameters:
+    resource (dict|list): FHIR resource, bundle as js object or array of resources This resource will be modified by this function to add type information.
+    path (string): fhirpath expression, sample 'Patient.name.given'
+    context (dict): a hash of variable name/value pairs.
+    model (dict): The "model" data object specific to a domain, e.g. R4.
+
+    Returns:
+    int: Description of return value
+
+    """
+    if isinstance(path, dict):
+        node = parse(path["expression"])
+        if "base" in path:
+            resource = ResourceNode.create_node(resource, path["base"])
+    else:
+        node = parse(path)
+
+    return apply_parsed_path(resource, node, context or {}, model, options)
+
+
+def compile(
+    path: str, model: dict | None = None, options: dict | None = None
+) -> Callable[[ResourceType, ContextType], list]:
+    """
+    Returns a function that takes a resource and an optional context hash (see
+    "evaluate"), and returns the result of evaluating the given FHIRPath
+    expression on that resource.  The advantage of this function over "evaluate"
+    is that if you have multiple resources, the given FHIRPath expression will
+    only be parsed once.
+
+    Parameters:
+    path (string) - the FHIRPath expression to be parsed.
+    model (dict) - The "model" data object specific to a domain, e.g. R4.
+
+    For example, you could pass in the result of require("fhirpath/fhir-context/r4")
+    """
+    return set_paths(apply_parsed_path, parsedPath=parse(path), model=model, options=options)
+
+
+InputType = TypeVar("InputType")
+OutputType = TypeVar("OutputType")
+# Contravariant: a callable accepting a wider input type is a valid subtype.
+_I_contra = TypeVar("_I_contra", contravariant=True)
+# Covariant: a callable returning a narrower output type is a valid subtype.
+# Sequence (read-only) is required here because list is invariant and rejects covariant TypeVars.
+_O_co = TypeVar("_O_co", covariant=True)
+
+
+class CompiledFirst(Protocol[_I_contra, _O_co]):
+    def __call__(self, resource: _I_contra, context: ContextType = ...) -> _O_co | None: ...
+
+
+class CompiledArray(Protocol[_I_contra, _O_co]):
+    def __call__(self, resource: _I_contra, context: ContextType = ...) -> Sequence[_O_co]: ...
+
+
+def compile_as_array(
+    expression: str, input_type: type[InputType], output_type: type[OutputType]
+) -> CompiledArray[InputType, OutputType]:
+    path_fn = compile(expression)
+
+    def fn(resource: Any, context: ContextType = None) -> Any:
+        return _format_result(
+            path_fn(_prepare_data(resource, input_type), context),
+            output_type,
+            is_array=True,
+        )
+
+    return cast(CompiledArray[InputType, OutputType], fn)
+
+
+def compile_as_first(
+    expression: str, input_type: type[InputType], output_type: type[OutputType]
+) -> CompiledFirst[InputType, OutputType]:
+    path_fn = compile(expression)
+
+    def fn(resource: Any, context: ContextType = None) -> Any:
+        return _format_result(
+            path_fn(_prepare_data(resource, input_type), context),
+            output_type,
+            is_array=False,
+        )
+
+    return cast(CompiledFirst[InputType, OutputType], fn)
+
+
+def _prepare_data(resource: Any, input_type: type[InputType]) -> ResourceType:
+    if not isinstance(resource, input_type):
+        raise Exception(
+            f"Resource type is {type(resource).__name__}, expected {input_type.__name__}"
+        )
+
+    if isinstance(resource, dict):
+        return resource
+
+    if hasattr(resource, "model_dump"):
+        return resource.model_dump()
+
+    raise Exception(f"Don't know how to work with type {type(resource).__name__}")
+
+
+def _format_result(result: list, output_type: type[OutputType], is_array=False) -> Any:
+    result = [_format_item(item, output_type) for item in result]
+
+    if is_array:
+        return result
+
+    if len(result) == 0:
+        return None
+
+    return result[0]
+
+
+def _format_item(item: Any, output_type: type[OutputType]) -> OutputType:
+    if hasattr(output_type, "model_validate"):
+        return cast(Any, output_type).model_validate(item)
+
+    if not isinstance(item, output_type):
+        raise Exception(
+            f"Expected result to be {output_type.__name__}, but got {type(item).__name__}"
+        )
+
+    return item

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

@@ -83,10 +83,11 @@ def doInvoke(ctx, fn_name, data, raw_params):
     params = []
     argTypes = invocation["arity"][paramsNumber]
 
+    thisValue = ctx["$this"] if "$this" in ctx else ctx["dataRoot"]
     for i in range(0, paramsNumber):
         tp = argTypes[i]
         pr = raw_params[i]
-        params.append(make_param(ctx, data, tp, pr))
+        params.append(make_param(ctx, thisValue, tp, pr))
 
     params.insert(0, data)
     params.insert(0, ctx)

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

@@ -174,6 +174,8 @@ 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 = fullPath.replace("_", "")
 
         actualTypes = None
         toAdd = None
@@ -212,16 +214,16 @@ def create_reduce_member_invocation(model, key):
 
         if util.is_some(toAdd):
             if isinstance(toAdd, list):
-                mapped = [nodes.ResourceNode.create_node(x, childPath) for x in 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))
+                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) for x in 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))
+                acc.append(nodes.ResourceNode.create_node(toAdd_, childPath, propName=fullPath))
         return acc
 
     return func

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

@@ -21,7 +21,12 @@ def iif_macro(ctx, data, cond, ok, fail=None):
 
 
 def trace_fn(ctx, x, label=""):
-    print("TRACE:[" + label + "]", str(x))
+    # Check if a custom trace callback is provided in the context
+    if "traceFn" in ctx and callable(ctx["traceFn"]):
+        ctx["traceFn"](label, x)
+    else:
+        # Fall back to console output if no callback is provided
+        print("TRACE:[" + label + "]", str(x))
     return x
 
 

fhirpathpy-2.2.0/fhirpathpy/engine/invocations/navigation.py

@@ -0,0 +1,81 @@
+from collections import abc
+from functools import reduce
+import fhirpathpy.engine.util as util
+import fhirpathpy.engine.nodes as nodes
+
+create_node = nodes.ResourceNode.create_node
+
+
+def create_reduce_children(ctx, exclude_primitive_extensions):
+    model = ctx["model"]
+
+    def func(acc, res):
+        data = util.get_data(res)
+        res = create_node(res)
+
+        if isinstance(data, list):
+            data = dict((i, data[i]) for i in range(0, len(data)))
+
+        if isinstance(data, abc.Mapping):
+            for prop in data.keys():
+                value = data[prop]
+                childPath = ""
+
+                # extensions shouldn't filter through here, yet they should for descendants?
+                # unless this item is the node that is being processed (primitive extension)
+                # though if you filter it, descendants will not work too
+                if prop.startswith("_") and exclude_primitive_extensions:
+                    continue
+
+                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 = fullPath.replace("_", "")
+
+                if prop == "extension":
+                    childPath = "Extension"
+
+                if (
+                    isinstance(model, dict)
+                    and "pathsDefinedElsewhere" in model
+                    and childPath in model["pathsDefinedElsewhere"]
+                ):
+                    childPath = model["pathsDefinedElsewhere"][childPath]
+
+                childPath = (
+                    model["path2Type"].get(childPath, childPath)
+                    if isinstance(model, dict) and "path2Type" in model
+                    else childPath
+                )
+
+                # 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)]
+                    actualTypes = model["choiceTypePaths"].get(altPropName, [])
+                    if len(actualTypes) > 0:
+                        # If it is, we can use it
+                        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)]
+                    acc = acc + mapped
+                else:
+                    acc.append(create_node(value, childPath, propName=fullPath))
+        return acc
+
+    return func
+
+
+def children(ctx, coll):
+    return reduce(create_reduce_children(ctx, True), coll, [])
+
+
+def descendants(ctx, coll):
+    res = []
+    ch = reduce(create_reduce_children(ctx, False), coll, [])
+    while len(ch) > 0:
+        res = res + ch
+        ch = reduce(create_reduce_children(ctx, False), ch, [])
+    return res

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

@@ -8,6 +8,7 @@ import math
 import json
 import re
 import time
+from typing import Optional
 
 
 timeRE = (
@@ -821,7 +822,7 @@ class ResourceNode:
     * @param _data additional data stored in a property named with "_" prepended.
     """
 
-    def __init__(self, data, path, _data=None):
+    def __init__(self, data, path, _data=None, propName=None, index=None):
         """
         If data is a resource (maybe a contained resource) reset the path
         information to the resource type.
@@ -832,6 +833,8 @@ class ResourceNode:
         self.path = path
         self.data = data
         self._data = _data
+        self.propName: Optional[str] = propName
+        self.index: Optional[int] = index
 
     def __eq__(self, value):
         if isinstance(value, ResourceNode):
@@ -864,10 +867,10 @@ class ResourceNode:
         return json.dumps(self.data)
 
     @staticmethod
-    def create_node(data, path=None, _data=None):
+    def create_node(data, path=None, _data=None, propName=None, index=None):
         if isinstance(data, ResourceNode):
             return data
-        return ResourceNode(data, path, _data)
+        return ResourceNode(data, path, _data, propName, index)
 
     def convert_data(self):
         data = self.data

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

@@ -1,17 +1,3 @@
-[tool.black]
-line-length = 100
-target-version = ['py311']
-exclude = '''
-(
-  /(
-    | \.git
-    | \.pytest_cache
-    | pyproject.toml
-    | dist
-  )/
-)
-'''
-
 [tool.pytest.ini_options]
 minversion = "6.0"
 addopts = "-ra -q --color=yes --cov=fhirpathpy --cov-report=xml"
@@ -40,17 +26,18 @@ classifiers = [
     "Operating System :: OS Independent",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Topic :: Internet :: WWW/HTTP",
     "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
 ]
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 
 [project.optional-dependencies]
-test = ["pytest==7.1.1", "pyyaml==5.4"]
+test = ["pytest==7.1.1", "pyyaml==5.4", "pydantic==2.13.1"]
 
 [project.urls]
 Homepage = "https://github.com/beda-software/fhirpath-py"
@@ -60,16 +47,22 @@ Changelog = "https://github.com/beda-software/fhirpath-py/blob/master/CHANGELOG.
 
 
 [tool.ruff]
-target-version = "py39"
+target-version = "py310"
 line-length = 100
-include = ["app/**/*.py", "tests/**/*.py"]
+include = ["fhirpathpy/**/*.py", "tests/**/*.py"]
 
 [tool.ruff.lint]
 select = ["B", "F", "I", "E", "UP", "N", "PL", "PERF"]
-# Black is responsible for E501
-ignore = ["E501"]
+# N803/N806 is not relevant for us because we use camelCase for historical reasons
+ignore = ["E501", "N803", "N806"]
 unfixable = ["F401"]
 
+[tool.mypy]
+python_version = "3.10"
+ignore_missing_imports = true
+plugins = ["pydantic.mypy"]
+
+
 [tool.autohooks]
 mode = "pipenv"
-pre-commit = ["autohooks.plugins.black", "autohooks.plugins.ruff"]
+pre-commit = ["autohooks.plugins.ruff.check", "autohooks.plugins.ruff.format"]

fhirpathpy-2.0.3/fhirpathpy/__init__.py

@@ -1,106 +0,0 @@
-from fhirpathpy.engine.invocations.constants import constants
-from fhirpathpy.parser import parse
-from fhirpathpy.engine import do_eval
-from fhirpathpy.engine.util import arraify, get_data, set_paths, process_user_invocation_table
-from fhirpathpy.engine.nodes import FP_Type, ResourceNode
-
-__title__ = "fhirpathpy"
-__version__ = "2.0.3"
-__author__ = "beda.software"
-__license__ = "MIT"
-__copyright__ = "Copyright 2025 beda.software"
-
-# Version synonym
-VERSION = __version__
-
-
-def apply_parsed_path(resource, parsedPath, context=None, model=None, options=None):
-    constants.reset()
-    dataRoot = arraify(resource)
-
-    """
-    do_eval takes a "ctx" object, and we store things in that as we parse, so we
-    need to put user-provided variable data in a sub-object, ctx['vars'].
-    Set up default standard variables, and allow override from the variables.
-    However, we'll keep our own copy of dataRoot for internal processing.
-    """
-    vars = {"context": resource, "ucum": "http://unitsofmeasure.org"}
-    vars.update(context or {})
-
-    ctx = {
-        "dataRoot": dataRoot,
-        "vars": vars,
-        "model": model,
-        "userInvocationTable": process_user_invocation_table(
-            (options or {}).get("userInvocationTable", {})
-        ),
-    }
-    node = do_eval(ctx, dataRoot, parsedPath["children"][0])
-
-    # Resolve any internal "ResourceNode" instances.  Continue to let FP_Type
-    # subclasses through.
-
-    def visit(node):
-        data = get_data(node)
-
-        if isinstance(node, list):
-            res = []
-            for item in data:
-                # Filter out intenal representation of primitive extensions
-                i = visit(item)
-                if isinstance(i, dict):
-                    keys = list(i.keys())
-                    if keys == ["extension"]:
-                        continue
-                res.append(i)
-            return res
-
-        if isinstance(data, dict) and not isinstance(data, FP_Type):
-            for key, value in data.items():
-                data[key] = visit(value)
-
-        return data
-
-    return visit(node)
-
-
-def evaluate(resource, path, context=None, model=None, options=None):
-    """
-    Evaluates the "path" FHIRPath expression on the given resource, using data
-    from "context" for variables mentioned in the "path" expression.
-
-    Parameters:
-    resource (dict|list): FHIR resource, bundle as js object or array of resources This resource will be modified by this function to add type information.
-    path (string): fhirpath expression, sample 'Patient.name.given'
-    context (dict): a hash of variable name/value pairs.
-    model (dict): The "model" data object specific to a domain, e.g. R4.
-
-    Returns:
-    int: Description of return value
-
-    """
-    if isinstance(path, dict):
-        node = parse(path["expression"])
-        if "base" in path:
-            resource = ResourceNode.create_node(resource, path["base"])
-    else:
-        node = parse(path)
-
-    return apply_parsed_path(resource, node, context or {}, model, options)
-
-
-def compile(path, model=None, options=None):
-    """
-    Returns a function that takes a resource and an optional context hash (see
-    "evaluate"), and returns the result of evaluating the given FHIRPath
-    expression on that resource.  The advantage of this function over "evaluate"
-    is that if you have multiple resources, the given FHIRPath expression will
-    only be parsed once.
-
-    Parameters:
-    path (string) - the FHIRPath expression to be parsed.
-    model (dict) - The "model" data object specific to a domain, e.g. R4.
-
-    For example, you could pass in the result of require("fhirpath/fhir-context/r4")
-    """
-    return set_paths(apply_parsed_path, parsedPath=parse(path), model=model, options=options)

fhirpathpy-2.0.3/fhirpathpy/engine/invocations/navigation.py

@@ -1,55 +0,0 @@
-from collections import abc
-from functools import reduce
-import fhirpathpy.engine.util as util
-import fhirpathpy.engine.nodes as nodes
-
-create_node = nodes.ResourceNode.create_node
-
-
-def create_reduce_children(ctx):
-    model = ctx["model"]
-
-    def func(acc, res):
-        data = util.get_data(res)
-        res = create_node(res)
-
-        if isinstance(data, list):
-            data = dict((i, data[i]) for i in range(0, len(data)))
-
-        if isinstance(data, abc.Mapping):
-            for prop in data.keys():
-                value = data[prop]
-                childPath = ""
-
-                if res.path is not None:
-                    childPath = res.path + "." + prop
-
-                if (
-                    isinstance(model, dict)
-                    and "pathsDefinedElsewhere" in model
-                    and childPath in model["pathsDefinedElsewhere"]
-                ):
-                    childPath = model["pathsDefinedElsewhere"][childPath]
-
-                if isinstance(value, list):
-                    mapped = [create_node(n, childPath) for n in value]
-                    acc = acc + mapped
-                else:
-                    acc.append(create_node(value, childPath))
-        return acc
-
-    return func
-
-
-def children(ctx, coll):
-    return reduce(create_reduce_children(ctx), coll, [])
-
-
-def descendants(ctx, coll):
-    res = []
-    ch = children(ctx, coll)
-    while len(ch) > 0:
-        res = res + ch
-        ch = children(ctx, ch)
-
-    return res