def __getattr__(self, name):
# for codes.X, X must be a CID or a scheme designator
if name.startswith("cid"):
if not self.scheme:
return _CID_Dict(int(name[3:]))
raise AttributeError("Cannot call cid selector on scheme dict")
if name in self._dict.keys():
# Return concepts limited only the specified scheme designator
return _CodesDict(scheme=name)
# If not already narrowed to a particular scheme, is an error
if not self.scheme:
msg = "'{}' not recognized as a CID or scheme designator"
raise AttributeError(msg.format(name))
# else try to find in this scheme
scheme = self.scheme
try:
val = self._dict[scheme][name]
except KeyError:
msg = "Unknown code name '{}' for scheme '{}'"
raise AttributeError(msg.format(name, scheme))
# val is like {code1: (meaning, cid_list}, code2: ...}
if len(val) > 1: # more than one code for this name
raise NotImplementedError("Need cid to disambiguate")
else:
code = list(val.keys())[0] # get first and only
meaning, cids = val[code]
return Code(value=code, meaning=meaning, scheme_designator=scheme)
def test_construction_args_optional(self):
version = "v1.0"
c = Code(self._value, self._scheme_designator, self._meaning, version)
assert c.value == self._value
assert c.scheme_designator == self._scheme_designator
assert c.meaning == self._meaning
assert c.scheme_version == version
def __getattr__(self, name: str) -> Union["_CodesDict", _CID_Dict, Code]:
"""Return either a ``_CodesDict``, ``_CID_Dict`` or ``Code`` depending
on the `name`.
Parameters
----------
name : str
One of the following:
* A coding scheme designator such as ``"SCT"``.
* A concept ID such as ``"CID2"``.
* If ``_CodesDict.scheme`` is not ``None``, a camel case version
of the concept's code meaning, such as ``"FontanelOfSkull" in
the SCT coding scheme.
Returns
-------
pydicom.sr._CodesDict, pydicom.sr._CID_Dict or pydicom.sr.Code
* If `name` is a concept ID then the ``_CID_Dict`` for the
corresponding CID.
* If `name` is a coding scheme designator then the ``_CodesDict``
instance for the corresponding scheme.
* If ``_CodesDict.scheme`` is not ``None`` then the ``Code``
corresponding to `name`.
"""
# for codes.X, X must be a CID or a scheme designator
if name.startswith("cid"):
if not self.scheme:
return _CID_Dict(int(name[3:]))
raise AttributeError("Cannot use a CID with a scheme dictionary")
if name in self._dict.keys():
# Return concepts limited only the specified scheme designator
return _CodesDict(scheme=name)
# If not already narrowed to a particular scheme, is an error
if not self.scheme:
raise AttributeError(
f"'{name}' not recognized as a CID or scheme designator")
# else try to find in this scheme
try:
val = cast(Dict[str, Tuple[str, List[int]]],
self._dict[self.scheme][name])
except KeyError:
raise AttributeError(
f"Unknown code name '{name}' for scheme '{self.scheme}'")
if len(val) > 1:
# val is {code value: (meaning, cid_list}, code_value: ...}
code_values = ", ".join(val.keys())
raise RuntimeError(
f"Multiple code values for '{name}' found: {code_values}")
code = list(val.keys())[0] # get first and only
meaning, cids = val[code]
return Code(value=code, meaning=meaning, scheme_designator=self.scheme)
def __getattr__(self, name):
matches = [
scheme for scheme, keywords in cid_concepts[self.cid].items()
if name in keywords
]
if not matches:
msg = "Identifier '{}' not found for cid{}".format(name, self.cid)
raise AttributeError(msg)
elif len(matches) > 1:
# Should never happen, but just in case
msg = "Multiple schemes found for '{}' in cid{}".format(name, cid)
raise AssertionError(msg)
else:
scheme = matches[0]
concept = concepts[scheme][name]
# Almost always only one code per concepts name
if len(concept) == 1:
code, val = list(concept.items())[0]
else:
matches = [(code, val) for code, val in concept.items()
if self.cid in val[1]]
if len(matches) > 1:
# Should never happen, but check in case
msg = "{} had multiple code matches for cid{}".format(
name, cid)
raise AssertionError(msg)
code, val = matches[0]
return Code(value=code, meaning=val[0], scheme_designator=scheme)
def test_use_as_dictionary_key(self):
c = Code(
value=self._value,
scheme_designator=self._scheme_designator,
meaning=self._meaning,
)
d = {c: 1}
assert c in d.keys()
def test_cid3263(self):
meaning = ("12-lead from EASI leads (ES, AS, AI)"
" by Dower/EASI transformation")
assert (codes.cid3263.
_12LeadFromEASILeadsESASAIByDowerEASITransformation == Code(
value="10:11284",
scheme_designator="MDC",
meaning=meaning,
))
def test_construction_kwargs(self):
c = Code(
value=self._value,
scheme_designator=self._scheme_designator,
meaning=self._meaning,
)
assert c.value == self._value
assert c.scheme_designator == self._scheme_designator
assert c.meaning == self._meaning
assert c.scheme_version is None
def test_num_item_construction_from_qualifier_code(self):
name = codes.SCT.Area
qualifier = Code('114000', 'SCT', 'Not a number')
i = NumContentItem(name=name, qualifier=qualifier)
assert i.ValueType == 'NUM'
assert i.ConceptNameCodeSequence[0] == name
with pytest.raises(AttributeError):
assert i.MeasuredValueSequence
with pytest.raises(AttributeError):
assert i.RelationshipType
qualifier_code_item = i.NumericValueQualifierCodeSequence[0]
assert qualifier_code_item.CodeValue == qualifier.value
def __eq__(self, other):
"""Compares `self` and `other` for equality.
Parameters
----------
other: Union[pydicom.sr.coding.CodedConcept, pydicom.sr.coding.Code]
code
Returns
-------
bool
whether `self` and `other` are considered equal
"""
return Code.__eq__(self, other)
def test_num_item_construction_from_float(self):
name = codes.SCT.Area
value = 100.0
unit = Code('um2', 'UCUM', 'Square Micrometer')
i = NumContentItem(name=name, value=value, unit=unit)
assert i.ValueType == 'NUM'
assert i.ConceptNameCodeSequence[0] == name
value_item = i.MeasuredValueSequence[0]
unit_code_item = value_item.MeasurementUnitsCodeSequence[0]
assert value_item.NumericValue == value
assert value_item.FloatingPointValue == value
assert unit_code_item.CodeValue == unit.value
assert unit_code_item.CodingSchemeDesignator == unit.scheme_designator
with pytest.raises(AttributeError):
assert i.RelationshipType
with pytest.raises(AttributeError):
assert i.NumericValueQualifierCodeSequence
def __getattr__(self, name: str) -> Code:
"""Return the ``Code`` for class attribute `name`."""
matches = [
scheme for scheme, keywords in CID_CONCEPTS[self.cid].items()
if name in keywords
]
if not matches:
raise AttributeError(f"'{name}' not found in CID {self.cid}")
if len(matches) > 1:
# Should never happen, but just in case
raise AttributeError(
f"Multiple schemes found for '{name}' in CID {self.cid}: "
f"{', '.join(matches)}")
scheme = matches[0]
identifiers = cast(Dict[str, Tuple[str, List[int]]],
CONCEPTS[scheme][name])
# Almost always only one code per identifier
if len(identifiers) == 1:
code, val = list(identifiers.items())[0]
else:
_matches = [(code, val) for code, val in identifiers.items()
if self.cid in val[1]]
if len(_matches) > 1:
# Rare, but multiple codes may end up with the same identifier
# See CID 12300 for example
codes = ", ".join([f"'{v[0]}'" for v in _matches])
raise AttributeError(
f"'{name}' has multiple code matches in CID {self.cid}: "
f"{codes}")
code, val = _matches[0]
return Code(value=code, meaning=val[0], scheme_designator=scheme)
def test_cid630(self):
assert codes.cid630.LidocainePrilocaine == Code(
value="346553009",
scheme_designator="SCT",
meaning="Lidocaine + Prilocaine",
)
def test_cid622(self):
assert codes.cid622.NeuromuscularBlockingNMBNonDepolarizing == Code(
value="372790002",
scheme_designator="SCT",
meaning="NeuroMuscular Blocking (NMB) - non depolarizing",
)
def test_cid612(self):
assert codes.cid612.MonitoredAnesthesiaCareMAC == Code(
value="398239001",
scheme_designator="SCT",
meaning="Monitored Anesthesia Care (MAC)",
)
def test_dcm_1(self):
assert codes.DCM.Modality == Code(
value="121139", scheme_designator="DCM", meaning="Modality"
)
def test_cid610(self):
assert codes.cid610.ReverseOsmosisPurifiedHclAcidifiedWater == Code(
value="127291",
scheme_designator="DCM",
meaning="Reverse osmosis purified, HCl acidified water",
)
def test_contained(self):
c = Code("24028007", "SCT", "Right")
assert c in codes.cid244
def test_cid300(self):
assert codes.cid300.NickelCobaltChromium == Code(
value="261249004",
scheme_designator="SCT",
meaning="Nickel cobalt chromium",
)
def test_cid301(self):
assert codes.cid301.mgcm3 == Code(
value="mg/cm3", scheme_designator="UCUM", meaning="mg/cm^3"
)
def test_cid3111(self):
assert codes.cid3111.Tc99mTetrofosmin == Code(
value="404707004",
scheme_designator="SCT",
meaning="Tc-99m tetrofosmin",
)
def test_cid250(self):
assert codes.cid250.Positive == Code(
value="10828004", scheme_designator="SCT", meaning="Positive"
)
def test_sct_1(self):
assert codes.SCT._1SigmaLowerValueOfPopulation == Code(
value="371919006",
scheme_designator="SCT",
meaning="1 Sigma Lower Value of Populuation",
)
def test_dcm_3(self):
assert codes.DCM.ImagingStartDatetime == Code(
value="122712",
scheme_designator="DCM",
meaning="Imaging Start DateTime",
)
def test_not_contained(self):
c = Code("130290", "DCM", "Median")
assert c not in codes.cid244
def test_cid643(self):
assert codes.cid643._6Hydroxydopamine == Code(
value="4624",
scheme_designator="PUBCHEM_CID",
meaning="6-Hydroxydopamine",
)
def test_cid402(self):
assert codes.cid402.DestinationRoleID == Code(
value="110152",
scheme_designator="DCM",
meaning="Destination Role ID",
)
def test_cid3107(self):
assert codes.cid3107._13Nitrogen == Code(
value="21576001", scheme_designator="SCT", meaning="^13^Nitrogen"
)
def test_cid405(self):
assert codes.cid405.MultiMediaCard == Code(
value="110035", scheme_designator="DCM", meaning="Multi-media Card"
)
def test_sct_2(self):
assert codes.SCT.FindingSite == Code(
value="363698007", scheme_designator="SCT", meaning="Finding Site"
)
def test_cid3335(self):
assert codes.cid3335.PWaveSecondDeflectionInPWave == Code(
value="10:320",
scheme_designator="MDC",
meaning="P' wave (second deflection in P wave)",
)
