onconova.interoperability.fhir.schemas.base

MappingRegistry()

Registry for managing bidirectional mappings between internal and FHIR values.

Source code in onconova/interoperability/fhir/schemas/base.py

def __init__(self):
    self._mappings: Dict[str, List[MappingRule]] = {}

get_rules(mapping_name)

Convert internal value to FHIR value.

Source code in onconova/interoperability/fhir/schemas/base.py

def get_rules(self, mapping_name: str) -> List[MappingRule]:
    """Convert internal value to FHIR value."""
    return self._mappings.get(mapping_name, [])

register(mapping_name, rules)

Register a set of mapping rules.

Source code in onconova/interoperability/fhir/schemas/base.py

def register(self, mapping_name: str, rules: List[MappingRule]):
    """Register a set of mapping rules."""
    self._mappings[mapping_name] = rules

to_fhir(mapping_name, internal_value)

Convert internal value to FHIR value.

Source code in onconova/interoperability/fhir/schemas/base.py

def to_fhir(self, mapping_name: str, internal_value: Any) -> Any:
    """Convert internal value to FHIR value."""
    rules = self.get_rules(mapping_name)
    for rule in rules:
        if rule.internal_value == internal_value:
            return rule.fhir_value

    if internal_value is None:
        return None

    raise KeyError(f"No FHIR mapping found for {mapping_name}: {internal_value}")

to_internal(mapping_name, fhir_value)

Convert FHIR value to internal value.

Source code in onconova/interoperability/fhir/schemas/base.py

def to_internal(self, mapping_name: str, fhir_value: Any) -> Any:
    """Convert FHIR value to internal value."""
    rules = self.get_rules(mapping_name)

    # Handle None/empty cases
    if fhir_value is None:
        # Return the default for the mapping if available
        defaults = [
            rule.internal_value
            for rule in rules
            if hasattr(rule.internal_value, "UNKNOWN")
        ]
        return defaults[0] if defaults else None

    # For Coding objects, compare by code and system
    if isinstance(fhir_value, Coding):
        for rule in rules:
            if (
                isinstance(rule.fhir_value, Coding)
                and rule.fhir_value.code == fhir_value.code
                and rule.fhir_value.system == fhir_value.system
            ):
                return rule.internal_value
    else:
        for rule in rules:
            if rule.fhir_value == fhir_value:
                return rule.internal_value

    raise KeyError(f"No internal mapping found for {mapping_name}: {fhir_value}")

MappingRule(internal_value, fhir_value, description=None) dataclass

Represents a bidirectional mapping rule between internal and FHIR values.

description class-attribute instance-attribute

fhir_value instance-attribute

internal_value instance-attribute

OnconovaFhirBaseSchema

Bases: BaseSchema

__model__ class-attribute

__registry__ class-attribute

__schema__ class-attribute

fhir_to_onconova(obj) classmethod

Source code in onconova/interoperability/fhir/schemas/base.py

@classmethod
def fhir_to_onconova(cls, obj: Any) -> BaseSchema:
    raise NotImplementedError("Subclasses must implement fhir_to_onconova method")

fhir_to_onconova_related(obj) classmethod

Source code in onconova/interoperability/fhir/schemas/base.py

@classmethod
def fhir_to_onconova_related(cls, obj: Any) -> Sequence[tuple[Model, BaseSchema]]:
    return []

get_orm_model(obj) classmethod

Source code in onconova/interoperability/fhir/schemas/base.py

@classmethod
def get_orm_model(cls, obj):  # type: ignore[override]
    return cls.__model__

get_orm_schema(obj) classmethod

Source code in onconova/interoperability/fhir/schemas/base.py

@classmethod
def get_orm_schema(cls, obj):
    return cls.__schema__

map_to_fhir(map, value) classmethod

Source code in onconova/interoperability/fhir/schemas/base.py

@classmethod
def map_to_fhir(cls, map: str, value: Any):
    return cls.__registry__.to_fhir(map, value)

map_to_internal(map, value) classmethod

Source code in onconova/interoperability/fhir/schemas/base.py

@classmethod
def map_to_internal(cls, map: str, value: Any):
    return cls.__registry__.to_internal(map, value)

onconova_to_fhir(obj) classmethod

Source code in onconova/interoperability/fhir/schemas/base.py

@classmethod
def onconova_to_fhir(cls, obj: Any) -> Any:
    raise NotImplementedError("Subclasses must implement onconova_to_fhir method")

pre_validator(obj) classmethod

Source code in onconova/interoperability/fhir/schemas/base.py

@model_validator(mode="before")
@classmethod
def pre_validator(cls, obj):
    try:
        if isinstance(obj, cls.__model__):
            obj = cls.get_orm_schema(obj).model_validate(obj)
        if isinstance(obj, DjangoGetter) and isinstance(obj._obj, cls.__model__):
            obj = cls.get_orm_schema(obj).model_validate(obj)
            return cls.onconova_to_fhir(obj)
        elif isinstance(obj, cls.get_orm_schema(obj)):
            return cls.onconova_to_fhir(obj)
    except TemplateSyntaxError:
        pass
    return obj

register_mapping(mapping_name, rules) classmethod

Source code in onconova/interoperability/fhir/schemas/base.py

@classmethod
def register_mapping(cls, mapping_name: str, rules: List[MappingRule]):
    return cls.__registry__.register(mapping_name, rules)

2026-04-262026-04-26runner