def _message(reader, elem):
"""Start of a Message."""
# <mes:Structure> within <mes:Header> of a data message is handled by
# _header_structure() below.
if getattr(elem.getparent(), "tag", None) == qname("mes", "Header"):
return
ss_without_dsd = False
# With 'dsd' argument, the message should be structure-specific
if ("StructureSpecific" in elem.tag
and reader.get_single(model.DataStructureDefinition) is None):
log.warning(
f"sdmxml.Reader got no dsd=… argument for {QName(elem).localname}")
ss_without_dsd = True
elif "StructureSpecific" not in elem.tag and reader.get_single(
model.DataStructureDefinition):
log.info(
"Use supplied dsd=… argument for non–structure-specific message")
# Store values for other methods
reader.push("SS without DSD", ss_without_dsd)
if "Data" in elem.tag:
reader.push("DataSetClass",
model.get_class(f"{QName(elem).localname}Set"))
# Instantiate the message object
cls = class_for_tag(elem.tag)
return cls()
def _ds_start(reader, elem):
# Create an instance of a DataSet subclass
ds = reader.peek("DataSetClass")()
# Store a reference to the DSD that structures the data set
id = elem.attrib.get("structureRef", None) or elem.attrib.get(
qname("data:structureRef"), None)
ds.structured_by = reader.get_single(id)
if not ds.structured_by: # pragma: no cover
raise RuntimeError("No DSD when creating DataSet")
reader.push("DataSet", ds)
def i11lstring(obj, name):
"""InternationalString.
Returns a list of elements with name `name`.
"""
elems = []
for locale, label in obj.localizations.items():
child = Element(name, label)
child.set(qname("xml", "lang"), locale)
elems.append(child)
return elems
def _group_ss(reader, elem):
ds = reader.get_single("DataSet")
attrib = copy(elem.attrib)
group_id = attrib.pop(qname("xsi", "type"), None)
gk = ds.structured_by.make_key(model.GroupKey,
attrib,
extend=reader.peek("SS without DSD"))
if group_id:
# The group_id is in a format like "foo:GroupName", where "foo" is an XML
# namespace
ns, group_id = group_id.split(":")
assert ns in elem.nsmap
try:
gk.described_by = ds.structured_by.group_dimensions[group_id]
except KeyError:
if not reader.peek("SS without DSD"):
raise
ds.group[gk] = []
def _localization(reader, elem):
reader.push(
elem,
(elem.attrib.get(qname("xml:lang"), model.DEFAULT_LOCALE), elem.text))
def to_tags(*args):
return chain(*[[qname(tag) for tag in arg.split()] for arg in args])
# navigating object relationships
TIME_FORMAT = s0_key.attrib["TIME_FORMAT"].value_for
assert len(TIME_FORMAT.related_to.dimensions) == 5
# Each entry is a tuple with 2 elements:
# 1. an instance of lxml.etree.Element to be parsed.
# 2. Either:
# - A sdmx.model object, in which case the parsed element must match the
# object.
# - A string, in which case parsing the element is expected to fail, raising
# an exception matching the string.
ELEMENTS = [
# xml._datetime()
( # with 5 decimal places
E(qname("mes:Extracted"), "2020-08-18T00:14:31.59849+05:00"),
datetime(2020,
8,
18,
0,
14,
31,
598490,
tzinfo=timezone(timedelta(hours=5))),
),
( # with 7 decimal places
E(qname("mes:Extracted"), "2020-08-18T01:02:03.4567891+00:00"),
datetime(2020, 8, 18, 1, 2, 3, 456789, tzinfo=timezone.utc),
),
( # with "Z"
E(qname("mes:Extracted"), "2020-08-18T00:14:31.59849Z"),
def Element(name, *args, **kwargs):
# Remove None
kwargs = dict(filter(lambda kv: kv[1] is not None, kwargs.items()))
return _element_maker(qname(name), *args, **kwargs)
