You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4165 lines
132 KiB
Python
4165 lines
132 KiB
Python
# This file was created by a source code generator:
|
|
# genxml2wrap.py
|
|
# Do not modify. Change the definition and
|
|
# run the generator again!
|
|
#
|
|
# (c) 2010 Mathias Hoffmann, GFZ Potsdam
|
|
#
|
|
#
|
|
|
|
from __future__ import (absolute_import, division, print_function,
|
|
unicode_literals)
|
|
|
|
try: str = unicode
|
|
except NameError: pass
|
|
|
|
import re
|
|
import datetime
|
|
|
|
def Property(func):
|
|
return property(**func())
|
|
|
|
try:
|
|
import xml.etree.cElementTree as ET # Python 2.5?
|
|
except ImportError:
|
|
import cElementTree as ET
|
|
|
|
try:
|
|
from decimal import Decimal # Python 2.4
|
|
_have_decimal = True
|
|
except ImportError:
|
|
_have_decimal = False # Will use float for decimal, hope it works
|
|
|
|
def _string_fromxml(val):
|
|
if val is None:
|
|
return ""
|
|
|
|
return val.strip()
|
|
|
|
def _string_toxml(val):
|
|
if val is None:
|
|
return ""
|
|
|
|
if isinstance(val, bytes):
|
|
try:
|
|
return val.decode("utf-8")
|
|
except UnicodeDecodeError:
|
|
return val.decode("iso-8859-1", "replace")
|
|
|
|
return str(val)
|
|
|
|
def _int_fromxml(val):
|
|
if val is None or val == "":
|
|
return None
|
|
|
|
return int(val)
|
|
|
|
_int_toxml = _string_toxml
|
|
|
|
def _float_fromxml(val):
|
|
if val is None or val == "":
|
|
return None
|
|
|
|
return float(val)
|
|
|
|
_float_toxml = _string_toxml
|
|
|
|
if _have_decimal:
|
|
def _decimal_fromxml(val):
|
|
if val is None or val == "":
|
|
return None
|
|
|
|
return Decimal(val)
|
|
else:
|
|
_decimal_fromxml = _float_fromxml
|
|
|
|
_decimal_toxml = _string_toxml
|
|
|
|
def _boolean_fromxml(val):
|
|
if val == "True" or val == "true":
|
|
return True
|
|
|
|
return False
|
|
|
|
def _boolean_toxml(val):
|
|
if val:
|
|
return "true"
|
|
|
|
return "false"
|
|
|
|
# DataModel.DEPLOYMENT == 0
|
|
# DataModel.ARRAY == 1
|
|
def _StationGroupType_toxml(val):
|
|
if val == 0:
|
|
return "DEPLOYMENT"
|
|
else:
|
|
return "ARRAY"
|
|
|
|
def _StationGroupType_fromxml(val):
|
|
if val == "DEPLOYMENT":
|
|
return 0
|
|
else:
|
|
return 1
|
|
|
|
_rx_datetime = re.compile("([0-9]{4})-([0-9]{2})-([0-9]{2})T" \
|
|
"([0-9]{2}):([0-9]{2}):([0-9]{2})(\.([0-9]*))?" \
|
|
"(Z|([+-])([0-9]{2}):([0-9]{2}))?$")
|
|
|
|
_rx_date = re.compile("([0-9]*)-([0-9]*)-([0-9]*)" \
|
|
"(Z|([+-])([0-9]{2}):([0-9]{2}))?$")
|
|
|
|
def _datetime_fromxml(val = ""):
|
|
if val is None or val == "":
|
|
return None
|
|
|
|
m = _rx_datetime.match(val)
|
|
if m is None:
|
|
m = _rx_date.match(val)
|
|
if m is None:
|
|
raise ValueError("invalid datetime: " + val)
|
|
|
|
(year, month, mday, tz, plusminus, tzhours, tzminutes) = m.groups()
|
|
|
|
try:
|
|
# ignore time zone
|
|
obj = datetime.datetime(int(year), int(month), int(mday), 0, 0, 0)
|
|
except ValueError:
|
|
raise ValueError("invalid datetime: " + val)
|
|
else:
|
|
(year, month, mday, hour, min, sec, sfdot, sfract,
|
|
tz, plusminus, tzhours, tzminutes) = m.groups()
|
|
|
|
if sfract is None:
|
|
sfract = "0"
|
|
|
|
try:
|
|
obj = datetime.datetime(int(year), int(month), int(mday),
|
|
int(hour), int(min), int(sec), int((sfract + "000000")[:6]))
|
|
if tz is not None and tz != "Z":
|
|
delta = datetime.timedelta(hours = int(tzhours),
|
|
minutes=int(tzminutes))
|
|
if plusminus == "-":
|
|
obj -= delta
|
|
else:
|
|
obj += delta
|
|
|
|
except ValueError:
|
|
raise ValueError("invalid datetime: " + val)
|
|
|
|
return obj
|
|
|
|
def _datetime_toxml(val):
|
|
if isinstance(val, datetime.datetime):
|
|
return "%04d-%02d-%02dT%02d:%02d:%02d.%04dZ" % (val.year, val.month, val.day, val.hour, val.minute,
|
|
val.second, val.microsecond / 100)
|
|
elif isinstance(val, datetime.date):
|
|
return "%04d-%02d-%02d" % (val.year, val.month, val.day)
|
|
|
|
elif val is None:
|
|
return ""
|
|
|
|
raise ValueError("invalid date or datetime object")
|
|
|
|
def _get_blob(e, name):
|
|
return _string_fromxml(e.findtext(name)).strip()
|
|
|
|
def _set_blob(e, name, value):
|
|
text = _string_toxml(value).strip()
|
|
e1 = ET.Element(name)
|
|
e1.text = text
|
|
e.append(e1)
|
|
|
|
def _get_quantity(e, name):
|
|
e1 = e.find(name)
|
|
if e1 is None:
|
|
return quantity()
|
|
|
|
return quantity(_float_fromxml(e1.text), unit=_string_fromxml(e1.get("unit")), error=_float_fromxml(e1.get("error")))
|
|
|
|
def _set_quantity(e, name, value):
|
|
e1 = ET.Element(name)
|
|
e1.text = _float_toxml(value)
|
|
e1.set("unit", _string_toxml(value.unit))
|
|
e1.set("error", _float_toxml(value.error))
|
|
e.append(e1)
|
|
#
|
|
#
|
|
|
|
|
|
|
|
|
|
# Inventory::Comment
|
|
class xml_Comment(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_Comment._xmlns + "comment")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.text = src.text
|
|
self.id = src.id
|
|
self.start = src.start
|
|
self.end = src.end
|
|
# creationInfo is an XML attribute, but we are missing
|
|
# CreationInfo_fromxml() [string->object] and _CreationInfo_toxml()
|
|
# [object->string] serialization within the creationInfo() property.
|
|
# Could be JSON??? Ignore CreationInfo for now.
|
|
#self.creationInfo = src.creationInfo
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("text") is not None:
|
|
dest.text = self.text
|
|
if self._element.get("id") is not None:
|
|
dest.id = self.id
|
|
if self._element.get("start") is not None:
|
|
dest.start = self.start
|
|
if self._element.get("end") is not None:
|
|
dest.end = self.end
|
|
if self._element.get("creationInfo") is not None:
|
|
dest.creationInfo = self.creationInfo
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def text():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("text"))
|
|
def fset(self, value):
|
|
self._element.set("text", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def id():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("id"))
|
|
def fset(self, value):
|
|
self._element.set("id", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def start():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("start"))
|
|
def fset(self, value):
|
|
self._element.set("start", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def end():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("end"))
|
|
def fset(self, value):
|
|
self._element.set("end", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def creationInfo():
|
|
# type: CreationInfo
|
|
def fget(self):
|
|
return _CreationInfo_fromxml(self._element.get("creationInfo"))
|
|
def fset(self, value):
|
|
self._element.set("creationInfo", _CreationInfo_toxml(value))
|
|
return locals()
|
|
|
|
|
|
# QualityControl::QCLog
|
|
class xml_QCLog(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/QualityControl/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_QCLog._xmlns + "qCLog")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.networkCode = src.networkCode
|
|
self.stationCode = src.stationCode
|
|
self.streamCode = src.streamCode
|
|
self.locationCode = src.locationCode
|
|
self.creatorID = src.creatorID
|
|
self.created = src.created
|
|
self.start = src.start
|
|
self.end = src.end
|
|
self.message = src.message
|
|
self.publicID = src.publicID
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("networkCode") is not None:
|
|
dest.networkCode = self.networkCode
|
|
if self._element.get("stationCode") is not None:
|
|
dest.stationCode = self.stationCode
|
|
if self._element.get("streamCode") is not None:
|
|
dest.streamCode = self.streamCode
|
|
if self._element.get("locationCode") is not None:
|
|
dest.locationCode = self.locationCode
|
|
if self._element.get("creatorID") is not None:
|
|
dest.creatorID = self.creatorID
|
|
if self._element.get("created") is not None:
|
|
dest.created = self.created
|
|
if self._element.get("start") is not None:
|
|
dest.start = self.start
|
|
if self._element.get("end") is not None:
|
|
dest.end = self.end
|
|
if self._element.get("message") is not None:
|
|
dest.message = self.message
|
|
if self._element.get("publicID") is not None:
|
|
dest.publicID = self.publicID
|
|
|
|
@Property
|
|
def publicID():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("publicID"))
|
|
def fset(self, value):
|
|
self._element.set("publicID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def networkCode():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("networkCode"))
|
|
def fset(self, value):
|
|
self._element.set("networkCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def stationCode():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("stationCode"))
|
|
def fset(self, value):
|
|
self._element.set("stationCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def streamCode():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("streamCode"))
|
|
def fset(self, value):
|
|
self._element.set("streamCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def locationCode():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("locationCode"))
|
|
def fset(self, value):
|
|
self._element.set("locationCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def creatorID():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("creatorID"))
|
|
def fset(self, value):
|
|
self._element.set("creatorID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def created():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("created"))
|
|
def fset(self, value):
|
|
self._element.set("created", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def start():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("start"))
|
|
def fset(self, value):
|
|
self._element.set("start", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def end():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("end"))
|
|
def fset(self, value):
|
|
self._element.set("end", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def message():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("message"))
|
|
def fset(self, value):
|
|
self._element.set("message", _string_toxml(value))
|
|
return locals()
|
|
|
|
|
|
# QualityControl::WaveformQuality
|
|
class xml_WaveformQuality(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/QualityControl/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_WaveformQuality._xmlns + "waveformQuality")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.networkCode = src.networkCode
|
|
self.stationCode = src.stationCode
|
|
self.streamCode = src.streamCode
|
|
self.locationCode = src.locationCode
|
|
self.creatorID = src.creatorID
|
|
self.created = src.created
|
|
self.start = src.start
|
|
self.end = src.end
|
|
self.type = src.type
|
|
self.parameter = src.parameter
|
|
self.value = src.value
|
|
self.lowerUncertainty = src.lowerUncertainty
|
|
self.upperUncertainty = src.upperUncertainty
|
|
self.windowLength = src.windowLength
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("networkCode") is not None:
|
|
dest.networkCode = self.networkCode
|
|
if self._element.get("stationCode") is not None:
|
|
dest.stationCode = self.stationCode
|
|
if self._element.get("streamCode") is not None:
|
|
dest.streamCode = self.streamCode
|
|
if self._element.get("locationCode") is not None:
|
|
dest.locationCode = self.locationCode
|
|
if self._element.get("creatorID") is not None:
|
|
dest.creatorID = self.creatorID
|
|
if self._element.get("created") is not None:
|
|
dest.created = self.created
|
|
if self._element.get("start") is not None:
|
|
dest.start = self.start
|
|
if self._element.get("end") is not None:
|
|
dest.end = self.end
|
|
if self._element.get("type") is not None:
|
|
dest.type = self.type
|
|
if self._element.get("parameter") is not None:
|
|
dest.parameter = self.parameter
|
|
if self._element.get("value") is not None:
|
|
dest.value = self.value
|
|
if self._element.get("lowerUncertainty") is not None:
|
|
dest.lowerUncertainty = self.lowerUncertainty
|
|
if self._element.get("upperUncertainty") is not None:
|
|
dest.upperUncertainty = self.upperUncertainty
|
|
if self._element.get("windowLength") is not None:
|
|
dest.windowLength = self.windowLength
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def networkCode():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("networkCode"))
|
|
def fset(self, value):
|
|
self._element.set("networkCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def stationCode():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("stationCode"))
|
|
def fset(self, value):
|
|
self._element.set("stationCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def streamCode():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("streamCode"))
|
|
def fset(self, value):
|
|
self._element.set("streamCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def locationCode():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("locationCode"))
|
|
def fset(self, value):
|
|
self._element.set("locationCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def creatorID():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("creatorID"))
|
|
def fset(self, value):
|
|
self._element.set("creatorID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def created():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("created"))
|
|
def fset(self, value):
|
|
self._element.set("created", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def start():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("start"))
|
|
def fset(self, value):
|
|
self._element.set("start", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def end():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("end"))
|
|
def fset(self, value):
|
|
self._element.set("end", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def type():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("type"))
|
|
def fset(self, value):
|
|
self._element.set("type", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def parameter():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("parameter"))
|
|
def fset(self, value):
|
|
self._element.set("parameter", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def value():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("value"))
|
|
def fset(self, value):
|
|
self._element.set("value", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def lowerUncertainty():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("lowerUncertainty"))
|
|
def fset(self, value):
|
|
self._element.set("lowerUncertainty", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def upperUncertainty():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("upperUncertainty"))
|
|
def fset(self, value):
|
|
self._element.set("upperUncertainty", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def windowLength():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("windowLength"))
|
|
def fset(self, value):
|
|
self._element.set("windowLength", _float_toxml(value))
|
|
return locals()
|
|
|
|
|
|
# QualityControl::Outage
|
|
class xml_Outage(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/QualityControl/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_Outage._xmlns + "outage")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.networkCode = src.networkCode
|
|
self.stationCode = src.stationCode
|
|
self.streamCode = src.streamCode
|
|
self.locationCode = src.locationCode
|
|
self.creatorID = src.creatorID
|
|
self.created = src.created
|
|
self.start = src.start
|
|
self.end = src.end
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("networkCode") is not None:
|
|
dest.networkCode = self.networkCode
|
|
if self._element.get("stationCode") is not None:
|
|
dest.stationCode = self.stationCode
|
|
if self._element.get("streamCode") is not None:
|
|
dest.streamCode = self.streamCode
|
|
if self._element.get("locationCode") is not None:
|
|
dest.locationCode = self.locationCode
|
|
if self._element.get("creatorID") is not None:
|
|
dest.creatorID = self.creatorID
|
|
if self._element.get("created") is not None:
|
|
dest.created = self.created
|
|
if self._element.get("start") is not None:
|
|
dest.start = self.start
|
|
if self._element.get("end") is not None:
|
|
dest.end = self.end
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def networkCode():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("networkCode"))
|
|
def fset(self, value):
|
|
self._element.set("networkCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def stationCode():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("stationCode"))
|
|
def fset(self, value):
|
|
self._element.set("stationCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def streamCode():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("streamCode"))
|
|
def fset(self, value):
|
|
self._element.set("streamCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def locationCode():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("locationCode"))
|
|
def fset(self, value):
|
|
self._element.set("locationCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def creatorID():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("creatorID"))
|
|
def fset(self, value):
|
|
self._element.set("creatorID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def created():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("created"))
|
|
def fset(self, value):
|
|
self._element.set("created", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def start():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("start"))
|
|
def fset(self, value):
|
|
self._element.set("start", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def end():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("end"))
|
|
def fset(self, value):
|
|
self._element.set("end", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
|
|
# QualityControl::QualityControl
|
|
class xml_QualityControl(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/QualityControl/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_QualityControl._xmlns + "qualityControl")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
pass
|
|
|
|
|
|
def _copy_to(self, dest):
|
|
pass
|
|
|
|
@Property
|
|
def publicID():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("publicID"))
|
|
def fset(self, value):
|
|
self._element.set("publicID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
# Aggregation: QCLog
|
|
def _new_log(self):
|
|
return xml_QCLog(ET.Element(xml_QCLog._xmlns + "log"))
|
|
@property
|
|
def log(self):
|
|
for e1 in self._element.findall(xml_QCLog._xmlns + "log"):
|
|
yield xml_QCLog(e1)
|
|
|
|
# Aggregation: WaveformQuality
|
|
def _new_waveformQuality(self):
|
|
return xml_WaveformQuality(ET.Element(xml_WaveformQuality._xmlns + "waveformQuality"))
|
|
@property
|
|
def waveformQuality(self):
|
|
for e1 in self._element.findall(xml_WaveformQuality._xmlns + "waveformQuality"):
|
|
yield xml_WaveformQuality(e1)
|
|
|
|
# Aggregation: Outage
|
|
def _new_outage(self):
|
|
return xml_Outage(ET.Element(xml_Outage._xmlns + "outage"))
|
|
@property
|
|
def outage(self):
|
|
for e1 in self._element.findall(xml_Outage._xmlns + "outage"):
|
|
yield xml_Outage(e1)
|
|
|
|
|
|
# Inventory::StationReference
|
|
class xml_StationReference(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_StationReference._xmlns + "stationReference")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.stationID = src.stationID
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("stationID") is not None:
|
|
dest.stationID = self.stationID
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def stationID():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("stationID"))
|
|
def fset(self, value):
|
|
self._element.set("stationID", _string_toxml(value))
|
|
return locals()
|
|
|
|
|
|
# Inventory::StationGroup
|
|
class xml_StationGroup(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_StationGroup._xmlns + "stationGroup")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.type = src.type
|
|
self.code = src.code
|
|
self.start = src.start
|
|
self.end = src.end
|
|
self.description = src.description
|
|
self.latitude = src.latitude
|
|
self.longitude = src.longitude
|
|
self.elevation = src.elevation
|
|
self.publicID = src.publicID
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("type") is not None:
|
|
dest.type = self.type
|
|
if self._element.get("code") is not None:
|
|
dest.code = self.code
|
|
if self._element.get("start") is not None:
|
|
dest.start = self.start
|
|
if self._element.get("end") is not None:
|
|
dest.end = self.end
|
|
if self._element.get("description") is not None:
|
|
dest.description = self.description
|
|
if self._element.get("latitude") is not None:
|
|
dest.latitude = self.latitude
|
|
if self._element.get("longitude") is not None:
|
|
dest.longitude = self.longitude
|
|
if self._element.get("elevation") is not None:
|
|
dest.elevation = self.elevation
|
|
if self._element.get("publicID") is not None:
|
|
dest.publicID = self.publicID
|
|
|
|
@Property
|
|
def publicID():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("publicID"))
|
|
def fset(self, value):
|
|
self._element.set("publicID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def type():
|
|
# type: StationGroupType
|
|
def fget(self):
|
|
return _StationGroupType_fromxml(self._element.get("type"))
|
|
def fset(self, value):
|
|
self._element.set("type", _StationGroupType_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def code():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("code"))
|
|
def fset(self, value):
|
|
self._element.set("code", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def start():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("start"))
|
|
def fset(self, value):
|
|
self._element.set("start", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def end():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("end"))
|
|
def fset(self, value):
|
|
self._element.set("end", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def description():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("description"))
|
|
def fset(self, value):
|
|
self._element.set("description", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def latitude():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("latitude"))
|
|
def fset(self, value):
|
|
self._element.set("latitude", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def longitude():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("longitude"))
|
|
def fset(self, value):
|
|
self._element.set("longitude", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def elevation():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("elevation"))
|
|
def fset(self, value):
|
|
self._element.set("elevation", _float_toxml(value))
|
|
return locals()
|
|
|
|
# Aggregation: StationReference
|
|
def _new_stationReference(self):
|
|
return xml_StationReference(ET.Element(xml_StationReference._xmlns + "stationReference"))
|
|
@property
|
|
def stationReference(self):
|
|
for e1 in self._element.findall(xml_StationReference._xmlns + "stationReference"):
|
|
yield xml_StationReference(e1)
|
|
|
|
|
|
# Inventory::AuxSource
|
|
class xml_AuxSource(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_AuxSource._xmlns + "auxSource")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.name = src.name
|
|
self.description = src.description
|
|
self.unit = src.unit
|
|
self.conversion = src.conversion
|
|
self.sampleRateNumerator = src.sampleRateNumerator
|
|
self.sampleRateDenominator = src.sampleRateDenominator
|
|
self.remark = src.remark
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("name") is not None:
|
|
dest.name = self.name
|
|
if self._element.get("description") is not None:
|
|
dest.description = self.description
|
|
if self._element.get("unit") is not None:
|
|
dest.unit = self.unit
|
|
if self._element.get("conversion") is not None:
|
|
dest.conversion = self.conversion
|
|
if self._element.get("sampleRateNumerator") is not None:
|
|
dest.sampleRateNumerator = self.sampleRateNumerator
|
|
if self._element.get("sampleRateDenominator") is not None:
|
|
dest.sampleRateDenominator = self.sampleRateDenominator
|
|
if self._element.find(xml_AuxSource._xmlns + "remark") is not None:
|
|
dest.remark = self.remark
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def name():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("name"))
|
|
def fset(self, value):
|
|
self._element.set("name", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def description():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("description"))
|
|
def fset(self, value):
|
|
self._element.set("description", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def unit():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("unit"))
|
|
def fset(self, value):
|
|
self._element.set("unit", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def conversion():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("conversion"))
|
|
def fset(self, value):
|
|
self._element.set("conversion", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def sampleRateNumerator():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("sampleRateNumerator"))
|
|
def fset(self, value):
|
|
self._element.set("sampleRateNumerator", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def sampleRateDenominator():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("sampleRateDenominator"))
|
|
def fset(self, value):
|
|
self._element.set("sampleRateDenominator", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def remark():
|
|
# type: Blob
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_AuxSource._xmlns + "remark")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_AuxSource._xmlns + "remark", value)
|
|
return locals()
|
|
|
|
|
|
# Inventory::AuxDevice
|
|
class xml_AuxDevice(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_AuxDevice._xmlns + "auxDevice")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.name = src.name
|
|
self.description = src.description
|
|
self.model = src.model
|
|
self.manufacturer = src.manufacturer
|
|
self.remark = src.remark
|
|
self.publicID = src.publicID
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("name") is not None:
|
|
dest.name = self.name
|
|
if self._element.get("description") is not None:
|
|
dest.description = self.description
|
|
if self._element.get("model") is not None:
|
|
dest.model = self.model
|
|
if self._element.get("manufacturer") is not None:
|
|
dest.manufacturer = self.manufacturer
|
|
if self._element.find(xml_AuxDevice._xmlns + "remark") is not None:
|
|
dest.remark = self.remark
|
|
if self._element.get("publicID") is not None:
|
|
dest.publicID = self.publicID
|
|
|
|
@Property
|
|
def publicID():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("publicID"))
|
|
def fset(self, value):
|
|
self._element.set("publicID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def name():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("name"))
|
|
def fset(self, value):
|
|
self._element.set("name", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def description():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("description"))
|
|
def fset(self, value):
|
|
self._element.set("description", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def model():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("model"))
|
|
def fset(self, value):
|
|
self._element.set("model", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def manufacturer():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("manufacturer"))
|
|
def fset(self, value):
|
|
self._element.set("manufacturer", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def remark():
|
|
# type: Blob
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_AuxDevice._xmlns + "remark")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_AuxDevice._xmlns + "remark", value)
|
|
return locals()
|
|
|
|
# Aggregation: AuxSource
|
|
def _new_source(self):
|
|
return xml_AuxSource(ET.Element(xml_AuxSource._xmlns + "source"))
|
|
@property
|
|
def source(self):
|
|
for e1 in self._element.findall(xml_AuxSource._xmlns + "source"):
|
|
yield xml_AuxSource(e1)
|
|
|
|
|
|
# Inventory::SensorCalibration
|
|
class xml_SensorCalibration(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_SensorCalibration._xmlns + "sensorCalibration")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.serialNumber = src.serialNumber
|
|
self.channel = src.channel
|
|
self.start = src.start
|
|
self.end = src.end
|
|
self.gain = src.gain
|
|
self.gainFrequency = src.gainFrequency
|
|
self.remark = src.remark
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("serialNumber") is not None:
|
|
dest.serialNumber = self.serialNumber
|
|
if self._element.get("channel") is not None:
|
|
dest.channel = self.channel
|
|
if self._element.get("start") is not None:
|
|
dest.start = self.start
|
|
if self._element.get("end") is not None:
|
|
dest.end = self.end
|
|
if self._element.get("gain") is not None:
|
|
dest.gain = self.gain
|
|
if self._element.get("gainFrequency") is not None:
|
|
dest.gainFrequency = self.gainFrequency
|
|
if self._element.find(xml_SensorCalibration._xmlns + "remark") is not None:
|
|
dest.remark = self.remark
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def serialNumber():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("serialNumber"))
|
|
def fset(self, value):
|
|
self._element.set("serialNumber", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def channel():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("channel"))
|
|
def fset(self, value):
|
|
self._element.set("channel", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def start():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("start"))
|
|
def fset(self, value):
|
|
self._element.set("start", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def end():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("end"))
|
|
def fset(self, value):
|
|
self._element.set("end", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def gain():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("gain"))
|
|
def fset(self, value):
|
|
self._element.set("gain", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def gainFrequency():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("gainFrequency"))
|
|
def fset(self, value):
|
|
self._element.set("gainFrequency", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def remark():
|
|
# type: Blob
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_SensorCalibration._xmlns + "remark")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_SensorCalibration._xmlns + "remark", value)
|
|
return locals()
|
|
|
|
|
|
# Inventory::Sensor
|
|
class xml_Sensor(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_Sensor._xmlns + "sensor")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.name = src.name
|
|
self.description = src.description
|
|
self.model = src.model
|
|
self.manufacturer = src.manufacturer
|
|
self.type = src.type
|
|
self.unit = src.unit
|
|
self.lowFrequency = src.lowFrequency
|
|
self.highFrequency = src.highFrequency
|
|
self.response = src.response
|
|
self.remark = src.remark
|
|
self.publicID = src.publicID
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("name") is not None:
|
|
dest.name = self.name
|
|
if self._element.get("description") is not None:
|
|
dest.description = self.description
|
|
if self._element.get("model") is not None:
|
|
dest.model = self.model
|
|
if self._element.get("manufacturer") is not None:
|
|
dest.manufacturer = self.manufacturer
|
|
if self._element.get("type") is not None:
|
|
dest.type = self.type
|
|
if self._element.get("unit") is not None:
|
|
dest.unit = self.unit
|
|
if self._element.get("lowFrequency") is not None:
|
|
dest.lowFrequency = self.lowFrequency
|
|
if self._element.get("highFrequency") is not None:
|
|
dest.highFrequency = self.highFrequency
|
|
if self._element.get("response") is not None:
|
|
dest.response = self.response
|
|
if self._element.find(xml_Sensor._xmlns + "remark") is not None:
|
|
dest.remark = self.remark
|
|
if self._element.get("publicID") is not None:
|
|
dest.publicID = self.publicID
|
|
|
|
@Property
|
|
def publicID():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("publicID"))
|
|
def fset(self, value):
|
|
self._element.set("publicID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def name():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("name"))
|
|
def fset(self, value):
|
|
self._element.set("name", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def description():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("description"))
|
|
def fset(self, value):
|
|
self._element.set("description", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def model():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("model"))
|
|
def fset(self, value):
|
|
self._element.set("model", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def manufacturer():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("manufacturer"))
|
|
def fset(self, value):
|
|
self._element.set("manufacturer", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def type():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("type"))
|
|
def fset(self, value):
|
|
self._element.set("type", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def unit():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("unit"))
|
|
def fset(self, value):
|
|
self._element.set("unit", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def lowFrequency():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("lowFrequency"))
|
|
def fset(self, value):
|
|
self._element.set("lowFrequency", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def highFrequency():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("highFrequency"))
|
|
def fset(self, value):
|
|
self._element.set("highFrequency", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def response():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("response"))
|
|
def fset(self, value):
|
|
self._element.set("response", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def remark():
|
|
# type: Blob
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_Sensor._xmlns + "remark")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_Sensor._xmlns + "remark", value)
|
|
return locals()
|
|
|
|
# Aggregation: SensorCalibration
|
|
def _new_calibration(self):
|
|
return xml_SensorCalibration(ET.Element(xml_SensorCalibration._xmlns + "calibration"))
|
|
@property
|
|
def calibration(self):
|
|
for e1 in self._element.findall(xml_SensorCalibration._xmlns + "calibration"):
|
|
yield xml_SensorCalibration(e1)
|
|
|
|
|
|
# Inventory::ResponsePAZ
|
|
class xml_ResponsePAZ(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_ResponsePAZ._xmlns + "responsePAZ")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.name = src.name
|
|
self.type = src.type
|
|
self.gain = src.gain
|
|
self.gainFrequency = src.gainFrequency
|
|
self.normalizationFactor = src.normalizationFactor
|
|
self.normalizationFrequency = src.normalizationFrequency
|
|
self.numberOfZeros = src.numberOfZeros
|
|
self.numberOfPoles = src.numberOfPoles
|
|
self.zeros = src.zeros
|
|
self.poles = src.poles
|
|
self.remark = src.remark
|
|
self.decimationFactor = src.decimationFactor
|
|
self.delay = src.delay
|
|
self.correction = src.correction
|
|
self.publicID = src.publicID
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("name") is not None:
|
|
dest.name = self.name
|
|
if self._element.get("type") is not None:
|
|
dest.type = self.type
|
|
if self._element.get("gain") is not None:
|
|
dest.gain = self.gain
|
|
if self._element.get("gainFrequency") is not None:
|
|
dest.gainFrequency = self.gainFrequency
|
|
if self._element.get("normalizationFactor") is not None:
|
|
dest.normalizationFactor = self.normalizationFactor
|
|
if self._element.get("normalizationFrequency") is not None:
|
|
dest.normalizationFrequency = self.normalizationFrequency
|
|
if self._element.get("numberOfZeros") is not None:
|
|
dest.numberOfZeros = self.numberOfZeros
|
|
if self._element.get("numberOfPoles") is not None:
|
|
dest.numberOfPoles = self.numberOfPoles
|
|
if self._element.find(xml_ResponsePAZ._xmlns + "zeros") is not None:
|
|
dest.zeros = self.zeros
|
|
if self._element.find(xml_ResponsePAZ._xmlns + "poles") is not None:
|
|
dest.poles = self.poles
|
|
if self._element.find(xml_ResponsePAZ._xmlns + "remark") is not None:
|
|
dest.remark = self.remark
|
|
if self._element.get("decimationFactor") is not None:
|
|
dest.decimationFactor = self.decimationFactor
|
|
if self._element.get("delay") is not None:
|
|
dest.delay = self.delay
|
|
if self._element.get("correction") is not None:
|
|
dest.correction = self.correction
|
|
if self._element.get("publicID") is not None:
|
|
dest.publicID = self.publicID
|
|
|
|
@Property
|
|
def publicID():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("publicID"))
|
|
def fset(self, value):
|
|
self._element.set("publicID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def name():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("name"))
|
|
def fset(self, value):
|
|
self._element.set("name", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def type():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("type"))
|
|
def fset(self, value):
|
|
self._element.set("type", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def gain():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("gain"))
|
|
def fset(self, value):
|
|
self._element.set("gain", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def gainFrequency():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("gainFrequency"))
|
|
def fset(self, value):
|
|
self._element.set("gainFrequency", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def normalizationFactor():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("normalizationFactor"))
|
|
def fset(self, value):
|
|
self._element.set("normalizationFactor", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def normalizationFrequency():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("normalizationFrequency"))
|
|
def fset(self, value):
|
|
self._element.set("normalizationFrequency", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def numberOfZeros():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("numberOfZeros"))
|
|
def fset(self, value):
|
|
self._element.set("numberOfZeros", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def numberOfPoles():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("numberOfPoles"))
|
|
def fset(self, value):
|
|
self._element.set("numberOfPoles", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def zeros():
|
|
# type: ComplexArray
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_ResponsePAZ._xmlns + "zeros")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_ResponsePAZ._xmlns + "zeros", value)
|
|
return locals()
|
|
|
|
@Property
|
|
def poles():
|
|
# type: ComplexArray
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_ResponsePAZ._xmlns + "poles")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_ResponsePAZ._xmlns + "poles", value)
|
|
return locals()
|
|
|
|
@Property
|
|
def remark():
|
|
# type: Blob
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_ResponsePAZ._xmlns + "remark")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_ResponsePAZ._xmlns + "remark", value)
|
|
return locals()
|
|
|
|
@Property
|
|
def decimationFactor():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("decimationFactor"))
|
|
def fset(self, value):
|
|
self._element.set("decimationFactor", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def delay():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("delay"))
|
|
def fset(self, value):
|
|
self._element.set("delay", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def correction():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("correction"))
|
|
def fset(self, value):
|
|
self._element.set("correction", _float_toxml(value))
|
|
return locals()
|
|
|
|
|
|
# Inventory::ResponsePolynomial
|
|
class xml_ResponsePolynomial(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_ResponsePolynomial._xmlns + "responsePolynomial")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.name = src.name
|
|
self.gain = src.gain
|
|
self.gainFrequency = src.gainFrequency
|
|
self.frequencyUnit = src.frequencyUnit
|
|
self.approximationType = src.approximationType
|
|
self.approximationLowerBound = src.approximationLowerBound
|
|
self.approximationUpperBound = src.approximationUpperBound
|
|
self.approximationError = src.approximationError
|
|
self.numberOfCoefficients = src.numberOfCoefficients
|
|
self.coefficients = src.coefficients
|
|
self.remark = src.remark
|
|
self.publicID = src.publicID
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("name") is not None:
|
|
dest.name = self.name
|
|
if self._element.get("gain") is not None:
|
|
dest.gain = self.gain
|
|
if self._element.get("gainFrequency") is not None:
|
|
dest.gainFrequency = self.gainFrequency
|
|
if self._element.get("frequencyUnit") is not None:
|
|
dest.frequencyUnit = self.frequencyUnit
|
|
if self._element.get("approximationType") is not None:
|
|
dest.approximationType = self.approximationType
|
|
if self._element.get("approximationLowerBound") is not None:
|
|
dest.approximationLowerBound = self.approximationLowerBound
|
|
if self._element.get("approximationUpperBound") is not None:
|
|
dest.approximationUpperBound = self.approximationUpperBound
|
|
if self._element.get("approximationError") is not None:
|
|
dest.approximationError = self.approximationError
|
|
if self._element.get("numberOfCoefficients") is not None:
|
|
dest.numberOfCoefficients = self.numberOfCoefficients
|
|
if self._element.find(xml_ResponsePolynomial._xmlns + "coefficients") is not None:
|
|
dest.coefficients = self.coefficients
|
|
if self._element.find(xml_ResponsePolynomial._xmlns + "remark") is not None:
|
|
dest.remark = self.remark
|
|
if self._element.get("publicID") is not None:
|
|
dest.publicID = self.publicID
|
|
|
|
@Property
|
|
def publicID():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("publicID"))
|
|
def fset(self, value):
|
|
self._element.set("publicID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def name():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("name"))
|
|
def fset(self, value):
|
|
self._element.set("name", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def gain():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("gain"))
|
|
def fset(self, value):
|
|
self._element.set("gain", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def gainFrequency():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("gainFrequency"))
|
|
def fset(self, value):
|
|
self._element.set("gainFrequency", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def frequencyUnit():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("frequencyUnit"))
|
|
def fset(self, value):
|
|
self._element.set("frequencyUnit", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def approximationType():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("approximationType"))
|
|
def fset(self, value):
|
|
self._element.set("approximationType", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def approximationLowerBound():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("approximationLowerBound"))
|
|
def fset(self, value):
|
|
self._element.set("approximationLowerBound", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def approximationUpperBound():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("approximationUpperBound"))
|
|
def fset(self, value):
|
|
self._element.set("approximationUpperBound", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def approximationError():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("approximationError"))
|
|
def fset(self, value):
|
|
self._element.set("approximationError", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def numberOfCoefficients():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("numberOfCoefficients"))
|
|
def fset(self, value):
|
|
self._element.set("numberOfCoefficients", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def coefficients():
|
|
# type: RealArray
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_ResponsePolynomial._xmlns + "coefficients")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_ResponsePolynomial._xmlns + "coefficients", value)
|
|
return locals()
|
|
|
|
@Property
|
|
def remark():
|
|
# type: Blob
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_ResponsePolynomial._xmlns + "remark")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_ResponsePolynomial._xmlns + "remark", value)
|
|
return locals()
|
|
|
|
|
|
# Inventory::ResponseFAP
|
|
class xml_ResponseFAP(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_ResponseFAP._xmlns + "responseFAP")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.name = src.name
|
|
self.gain = src.gain
|
|
self.gainFrequency = src.gainFrequency
|
|
self.numberOfTuples = src.numberOfTuples
|
|
self.tuples = src.tuples
|
|
self.remark = src.remark
|
|
self.publicID = src.publicID
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("name") is not None:
|
|
dest.name = self.name
|
|
if self._element.get("gain") is not None:
|
|
dest.gain = self.gain
|
|
if self._element.get("gainFrequency") is not None:
|
|
dest.gainFrequency = self.gainFrequency
|
|
if self._element.get("numberOfTuples") is not None:
|
|
dest.numberOfTuples = self.numberOfTuples
|
|
if self._element.find(xml_ResponseFAP._xmlns + "tuples") is not None:
|
|
dest.tuples = self.tuples
|
|
if self._element.find(xml_ResponseFAP._xmlns + "remark") is not None:
|
|
dest.remark = self.remark
|
|
if self._element.get("publicID") is not None:
|
|
dest.publicID = self.publicID
|
|
|
|
@Property
|
|
def publicID():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("publicID"))
|
|
def fset(self, value):
|
|
self._element.set("publicID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def name():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("name"))
|
|
def fset(self, value):
|
|
self._element.set("name", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def gain():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("gain"))
|
|
def fset(self, value):
|
|
self._element.set("gain", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def gainFrequency():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("gainFrequency"))
|
|
def fset(self, value):
|
|
self._element.set("gainFrequency", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def numberOfTuples():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("numberOfTuples"))
|
|
def fset(self, value):
|
|
self._element.set("numberOfTuples", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def tuples():
|
|
# type: RealArray
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_ResponseFAP._xmlns + "tuples")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_ResponseFAP._xmlns + "tuples", value)
|
|
return locals()
|
|
|
|
@Property
|
|
def remark():
|
|
# type: Blob
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_ResponseFAP._xmlns + "remark")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_ResponseFAP._xmlns + "remark", value)
|
|
return locals()
|
|
|
|
|
|
# Inventory::ResponseFIR
|
|
class xml_ResponseFIR(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_ResponseFIR._xmlns + "responseFIR")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.name = src.name
|
|
self.gain = src.gain
|
|
self.gainFrequency = src.gainFrequency
|
|
self.decimationFactor = src.decimationFactor
|
|
self.delay = src.delay
|
|
self.correction = src.correction
|
|
self.numberOfCoefficients = src.numberOfCoefficients
|
|
self.symmetry = src.symmetry
|
|
self.coefficients = src.coefficients
|
|
self.remark = src.remark
|
|
self.publicID = src.publicID
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("name") is not None:
|
|
dest.name = self.name
|
|
if self._element.get("gain") is not None:
|
|
dest.gain = self.gain
|
|
if self._element.get("gainFrequency") is not None:
|
|
dest.gainFrequency = self.gainFrequency
|
|
if self._element.get("decimationFactor") is not None:
|
|
dest.decimationFactor = self.decimationFactor
|
|
if self._element.get("delay") is not None:
|
|
dest.delay = self.delay
|
|
if self._element.get("correction") is not None:
|
|
dest.correction = self.correction
|
|
if self._element.get("numberOfCoefficients") is not None:
|
|
dest.numberOfCoefficients = self.numberOfCoefficients
|
|
if self._element.get("symmetry") is not None:
|
|
dest.symmetry = self.symmetry
|
|
if self._element.find(xml_ResponseFIR._xmlns + "coefficients") is not None:
|
|
dest.coefficients = self.coefficients
|
|
if self._element.find(xml_ResponseFIR._xmlns + "remark") is not None:
|
|
dest.remark = self.remark
|
|
if self._element.get("publicID") is not None:
|
|
dest.publicID = self.publicID
|
|
|
|
@Property
|
|
def publicID():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("publicID"))
|
|
def fset(self, value):
|
|
self._element.set("publicID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def name():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("name"))
|
|
def fset(self, value):
|
|
self._element.set("name", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def gain():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("gain"))
|
|
def fset(self, value):
|
|
self._element.set("gain", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def gainFrequency():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("gainFrequency"))
|
|
def fset(self, value):
|
|
self._element.set("gainFrequency", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def decimationFactor():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("decimationFactor"))
|
|
def fset(self, value):
|
|
self._element.set("decimationFactor", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def delay():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("delay"))
|
|
def fset(self, value):
|
|
self._element.set("delay", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def correction():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("correction"))
|
|
def fset(self, value):
|
|
self._element.set("correction", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def numberOfCoefficients():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("numberOfCoefficients"))
|
|
def fset(self, value):
|
|
self._element.set("numberOfCoefficients", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def symmetry():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("symmetry"))
|
|
def fset(self, value):
|
|
self._element.set("symmetry", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def coefficients():
|
|
# type: RealArray
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_ResponseFIR._xmlns + "coefficients")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_ResponseFIR._xmlns + "coefficients", value)
|
|
return locals()
|
|
|
|
@Property
|
|
def remark():
|
|
# type: Blob
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_ResponseFIR._xmlns + "remark")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_ResponseFIR._xmlns + "remark", value)
|
|
return locals()
|
|
|
|
|
|
# Inventory::ResponseIIR
|
|
class xml_ResponseIIR(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_ResponseIIR._xmlns + "responseIIR")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.name = src.name
|
|
self.type = src.type
|
|
self.gain = src.gain
|
|
self.gainFrequency = src.gainFrequency
|
|
self.decimationFactor = src.decimationFactor
|
|
self.delay = src.delay
|
|
self.correction = src.correction
|
|
self.numberOfNumerators = src.numberOfNumerators
|
|
self.numberOfDenominators = src.numberOfDenominators
|
|
self.numerators = src.numerators
|
|
self.denominators = src.denominators
|
|
self.remark = src.remark
|
|
self.publicID = src.publicID
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("name") is not None:
|
|
dest.name = self.name
|
|
if self._element.get("type") is not None:
|
|
dest.type = self.type
|
|
if self._element.get("gain") is not None:
|
|
dest.gain = self.gain
|
|
if self._element.get("gainFrequency") is not None:
|
|
dest.gainFrequency = self.gainFrequency
|
|
if self._element.get("decimationFactor") is not None:
|
|
dest.decimationFactor = self.decimationFactor
|
|
if self._element.get("delay") is not None:
|
|
dest.delay = self.delay
|
|
if self._element.get("correction") is not None:
|
|
dest.correction = self.correction
|
|
if self._element.get("numberOfNumerators") is not None:
|
|
dest.numberOfNumerators = self.numberOfNumerators
|
|
if self._element.get("numberOfDenominators") is not None:
|
|
dest.numberOfDenominators = self.numberOfDenominators
|
|
if self._element.find(xml_ResponseIIR._xmlns + "numerators") is not None:
|
|
dest.numerators = self.numerators
|
|
if self._element.find(xml_ResponseIIR._xmlns + "denominators") is not None:
|
|
dest.denominators = self.denominators
|
|
if self._element.find(xml_ResponseIIR._xmlns + "remark") is not None:
|
|
dest.remark = self.remark
|
|
if self._element.get("publicID") is not None:
|
|
dest.publicID = self.publicID
|
|
|
|
@Property
|
|
def publicID():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("publicID"))
|
|
def fset(self, value):
|
|
self._element.set("publicID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def name():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("name"))
|
|
def fset(self, value):
|
|
self._element.set("name", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def type():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("type"))
|
|
def fset(self, value):
|
|
self._element.set("type", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def gain():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("gain"))
|
|
def fset(self, value):
|
|
self._element.set("gain", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def gainFrequency():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("gainFrequency"))
|
|
def fset(self, value):
|
|
self._element.set("gainFrequency", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def decimationFactor():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("decimationFactor"))
|
|
def fset(self, value):
|
|
self._element.set("decimationFactor", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def delay():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("delay"))
|
|
def fset(self, value):
|
|
self._element.set("delay", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def correction():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("correction"))
|
|
def fset(self, value):
|
|
self._element.set("correction", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def numberOfNumerators():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("numberOfNumerators"))
|
|
def fset(self, value):
|
|
self._element.set("numberOfNumerators", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def numberOfDenominators():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("numberOfDenominators"))
|
|
def fset(self, value):
|
|
self._element.set("numberOfDenominators", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def numerators():
|
|
# type: RealArray
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_ResponseIIR._xmlns + "numerators")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_ResponseIIR._xmlns + "numerators", value)
|
|
return locals()
|
|
|
|
@Property
|
|
def denominators():
|
|
# type: RealArray
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_ResponseIIR._xmlns + "denominators")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_ResponseIIR._xmlns + "denominators", value)
|
|
return locals()
|
|
|
|
@Property
|
|
def remark():
|
|
# type: Blob
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_ResponseIIR._xmlns + "remark")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_ResponseIIR._xmlns + "remark", value)
|
|
return locals()
|
|
|
|
|
|
# Inventory::DataloggerCalibration
|
|
class xml_DataloggerCalibration(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_DataloggerCalibration._xmlns + "dataloggerCalibration")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.serialNumber = src.serialNumber
|
|
self.channel = src.channel
|
|
self.start = src.start
|
|
self.end = src.end
|
|
self.gain = src.gain
|
|
self.gainFrequency = src.gainFrequency
|
|
self.remark = src.remark
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("serialNumber") is not None:
|
|
dest.serialNumber = self.serialNumber
|
|
if self._element.get("channel") is not None:
|
|
dest.channel = self.channel
|
|
if self._element.get("start") is not None:
|
|
dest.start = self.start
|
|
if self._element.get("end") is not None:
|
|
dest.end = self.end
|
|
if self._element.get("gain") is not None:
|
|
dest.gain = self.gain
|
|
if self._element.get("gainFrequency") is not None:
|
|
dest.gainFrequency = self.gainFrequency
|
|
if self._element.find(xml_DataloggerCalibration._xmlns + "remark") is not None:
|
|
dest.remark = self.remark
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def serialNumber():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("serialNumber"))
|
|
def fset(self, value):
|
|
self._element.set("serialNumber", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def channel():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("channel"))
|
|
def fset(self, value):
|
|
self._element.set("channel", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def start():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("start"))
|
|
def fset(self, value):
|
|
self._element.set("start", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def end():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("end"))
|
|
def fset(self, value):
|
|
self._element.set("end", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def gain():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("gain"))
|
|
def fset(self, value):
|
|
self._element.set("gain", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def gainFrequency():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("gainFrequency"))
|
|
def fset(self, value):
|
|
self._element.set("gainFrequency", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def remark():
|
|
# type: Blob
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_DataloggerCalibration._xmlns + "remark")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_DataloggerCalibration._xmlns + "remark", value)
|
|
return locals()
|
|
|
|
|
|
# Inventory::Decimation
|
|
class xml_Decimation(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_Decimation._xmlns + "decimation")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.sampleRateNumerator = src.sampleRateNumerator
|
|
self.sampleRateDenominator = src.sampleRateDenominator
|
|
self.analogueFilterChain = src.analogueFilterChain
|
|
self.digitalFilterChain = src.digitalFilterChain
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("sampleRateNumerator") is not None:
|
|
dest.sampleRateNumerator = self.sampleRateNumerator
|
|
if self._element.get("sampleRateDenominator") is not None:
|
|
dest.sampleRateDenominator = self.sampleRateDenominator
|
|
if self._element.find(xml_Decimation._xmlns + "analogueFilterChain") is not None:
|
|
dest.analogueFilterChain = self.analogueFilterChain
|
|
if self._element.find(xml_Decimation._xmlns + "digitalFilterChain") is not None:
|
|
dest.digitalFilterChain = self.digitalFilterChain
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def sampleRateNumerator():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("sampleRateNumerator"))
|
|
def fset(self, value):
|
|
self._element.set("sampleRateNumerator", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def sampleRateDenominator():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("sampleRateDenominator"))
|
|
def fset(self, value):
|
|
self._element.set("sampleRateDenominator", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def analogueFilterChain():
|
|
# type: Blob
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_Decimation._xmlns + "analogueFilterChain")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_Decimation._xmlns + "analogueFilterChain", value)
|
|
return locals()
|
|
|
|
@Property
|
|
def digitalFilterChain():
|
|
# type: Blob
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_Decimation._xmlns + "digitalFilterChain")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_Decimation._xmlns + "digitalFilterChain", value)
|
|
return locals()
|
|
|
|
|
|
# Inventory::Datalogger
|
|
class xml_Datalogger(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_Datalogger._xmlns + "datalogger")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.name = src.name
|
|
self.description = src.description
|
|
self.digitizerModel = src.digitizerModel
|
|
self.digitizerManufacturer = src.digitizerManufacturer
|
|
self.recorderModel = src.recorderModel
|
|
self.recorderManufacturer = src.recorderManufacturer
|
|
self.clockModel = src.clockModel
|
|
self.clockManufacturer = src.clockManufacturer
|
|
self.clockType = src.clockType
|
|
self.gain = src.gain
|
|
self.maxClockDrift = src.maxClockDrift
|
|
self.remark = src.remark
|
|
self.publicID = src.publicID
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("name") is not None:
|
|
dest.name = self.name
|
|
if self._element.get("description") is not None:
|
|
dest.description = self.description
|
|
if self._element.get("digitizerModel") is not None:
|
|
dest.digitizerModel = self.digitizerModel
|
|
if self._element.get("digitizerManufacturer") is not None:
|
|
dest.digitizerManufacturer = self.digitizerManufacturer
|
|
if self._element.get("recorderModel") is not None:
|
|
dest.recorderModel = self.recorderModel
|
|
if self._element.get("recorderManufacturer") is not None:
|
|
dest.recorderManufacturer = self.recorderManufacturer
|
|
if self._element.get("clockModel") is not None:
|
|
dest.clockModel = self.clockModel
|
|
if self._element.get("clockManufacturer") is not None:
|
|
dest.clockManufacturer = self.clockManufacturer
|
|
if self._element.get("clockType") is not None:
|
|
dest.clockType = self.clockType
|
|
if self._element.get("gain") is not None:
|
|
dest.gain = self.gain
|
|
if self._element.get("maxClockDrift") is not None:
|
|
dest.maxClockDrift = self.maxClockDrift
|
|
if self._element.find(xml_Datalogger._xmlns + "remark") is not None:
|
|
dest.remark = self.remark
|
|
if self._element.get("publicID") is not None:
|
|
dest.publicID = self.publicID
|
|
|
|
@Property
|
|
def publicID():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("publicID"))
|
|
def fset(self, value):
|
|
self._element.set("publicID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def name():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("name"))
|
|
def fset(self, value):
|
|
self._element.set("name", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def description():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("description"))
|
|
def fset(self, value):
|
|
self._element.set("description", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def digitizerModel():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("digitizerModel"))
|
|
def fset(self, value):
|
|
self._element.set("digitizerModel", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def digitizerManufacturer():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("digitizerManufacturer"))
|
|
def fset(self, value):
|
|
self._element.set("digitizerManufacturer", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def recorderModel():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("recorderModel"))
|
|
def fset(self, value):
|
|
self._element.set("recorderModel", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def recorderManufacturer():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("recorderManufacturer"))
|
|
def fset(self, value):
|
|
self._element.set("recorderManufacturer", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def clockModel():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("clockModel"))
|
|
def fset(self, value):
|
|
self._element.set("clockModel", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def clockManufacturer():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("clockManufacturer"))
|
|
def fset(self, value):
|
|
self._element.set("clockManufacturer", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def clockType():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("clockType"))
|
|
def fset(self, value):
|
|
self._element.set("clockType", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def gain():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("gain"))
|
|
def fset(self, value):
|
|
self._element.set("gain", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def maxClockDrift():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("maxClockDrift"))
|
|
def fset(self, value):
|
|
self._element.set("maxClockDrift", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def remark():
|
|
# type: Blob
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_Datalogger._xmlns + "remark")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_Datalogger._xmlns + "remark", value)
|
|
return locals()
|
|
|
|
# Aggregation: DataloggerCalibration
|
|
def _new_calibration(self):
|
|
return xml_DataloggerCalibration(ET.Element(xml_DataloggerCalibration._xmlns + "calibration"))
|
|
@property
|
|
def calibration(self):
|
|
for e1 in self._element.findall(xml_DataloggerCalibration._xmlns + "calibration"):
|
|
yield xml_DataloggerCalibration(e1)
|
|
|
|
# Aggregation: Decimation
|
|
def _new_decimation(self):
|
|
return xml_Decimation(ET.Element(xml_Decimation._xmlns + "decimation"))
|
|
@property
|
|
def decimation(self):
|
|
for e1 in self._element.findall(xml_Decimation._xmlns + "decimation"):
|
|
yield xml_Decimation(e1)
|
|
|
|
|
|
# Inventory::AuxStream
|
|
class xml_AuxStream(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_AuxStream._xmlns + "auxStream")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.code = src.code
|
|
self.start = src.start
|
|
self.end = src.end
|
|
self.device = src.device
|
|
self.deviceSerialNumber = src.deviceSerialNumber
|
|
self.source = src.source
|
|
self.format = src.format
|
|
self.flags = src.flags
|
|
self.restricted = src.restricted
|
|
self.shared = src.shared
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("code") is not None:
|
|
dest.code = self.code
|
|
if self._element.get("start") is not None:
|
|
dest.start = self.start
|
|
if self._element.get("end") is not None:
|
|
dest.end = self.end
|
|
if self._element.get("device") is not None:
|
|
dest.device = self.device
|
|
if self._element.get("deviceSerialNumber") is not None:
|
|
dest.deviceSerialNumber = self.deviceSerialNumber
|
|
if self._element.get("source") is not None:
|
|
dest.source = self.source
|
|
if self._element.get("format") is not None:
|
|
dest.format = self.format
|
|
if self._element.get("flags") is not None:
|
|
dest.flags = self.flags
|
|
if self._element.get("restricted") is not None:
|
|
dest.restricted = self.restricted
|
|
if self._element.get("shared") is not None:
|
|
dest.shared = self.shared
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def code():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("code"))
|
|
def fset(self, value):
|
|
self._element.set("code", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def start():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("start"))
|
|
def fset(self, value):
|
|
self._element.set("start", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def end():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("end"))
|
|
def fset(self, value):
|
|
self._element.set("end", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def device():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("device"))
|
|
def fset(self, value):
|
|
self._element.set("device", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def deviceSerialNumber():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("deviceSerialNumber"))
|
|
def fset(self, value):
|
|
self._element.set("deviceSerialNumber", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def source():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("source"))
|
|
def fset(self, value):
|
|
self._element.set("source", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def format():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("format"))
|
|
def fset(self, value):
|
|
self._element.set("format", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def flags():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("flags"))
|
|
def fset(self, value):
|
|
self._element.set("flags", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def restricted():
|
|
# type: boolean
|
|
def fget(self):
|
|
return _boolean_fromxml(self._element.get("restricted"))
|
|
def fset(self, value):
|
|
self._element.set("restricted", _boolean_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def shared():
|
|
# type: boolean
|
|
def fget(self):
|
|
return _boolean_fromxml(self._element.get("shared"))
|
|
def fset(self, value):
|
|
self._element.set("shared", _boolean_toxml(value))
|
|
return locals()
|
|
|
|
|
|
# Inventory::Stream
|
|
class xml_Stream(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_Stream._xmlns + "stream")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.code = src.code
|
|
self.start = src.start
|
|
self.end = src.end
|
|
self.datalogger = src.datalogger
|
|
self.dataloggerSerialNumber = src.dataloggerSerialNumber
|
|
self.dataloggerChannel = src.dataloggerChannel
|
|
self.sensor = src.sensor
|
|
self.sensorSerialNumber = src.sensorSerialNumber
|
|
self.sensorChannel = src.sensorChannel
|
|
self.clockSerialNumber = src.clockSerialNumber
|
|
self.sampleRateNumerator = src.sampleRateNumerator
|
|
self.sampleRateDenominator = src.sampleRateDenominator
|
|
self.depth = src.depth
|
|
self.azimuth = src.azimuth
|
|
self.dip = src.dip
|
|
self.gain = src.gain
|
|
self.gainFrequency = src.gainFrequency
|
|
self.gainUnit = src.gainUnit
|
|
self.format = src.format
|
|
self.flags = src.flags
|
|
self.restricted = src.restricted
|
|
self.shared = src.shared
|
|
self.publicID = src.publicID
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("code") is not None:
|
|
dest.code = self.code
|
|
if self._element.get("start") is not None:
|
|
dest.start = self.start
|
|
if self._element.get("end") is not None:
|
|
dest.end = self.end
|
|
if self._element.get("datalogger") is not None:
|
|
dest.datalogger = self.datalogger
|
|
if self._element.get("dataloggerSerialNumber") is not None:
|
|
dest.dataloggerSerialNumber = self.dataloggerSerialNumber
|
|
if self._element.get("dataloggerChannel") is not None:
|
|
dest.dataloggerChannel = self.dataloggerChannel
|
|
if self._element.get("sensor") is not None:
|
|
dest.sensor = self.sensor
|
|
if self._element.get("sensorSerialNumber") is not None:
|
|
dest.sensorSerialNumber = self.sensorSerialNumber
|
|
if self._element.get("sensorChannel") is not None:
|
|
dest.sensorChannel = self.sensorChannel
|
|
if self._element.get("clockSerialNumber") is not None:
|
|
dest.clockSerialNumber = self.clockSerialNumber
|
|
if self._element.get("sampleRateNumerator") is not None:
|
|
dest.sampleRateNumerator = self.sampleRateNumerator
|
|
if self._element.get("sampleRateDenominator") is not None:
|
|
dest.sampleRateDenominator = self.sampleRateDenominator
|
|
if self._element.get("depth") is not None:
|
|
dest.depth = self.depth
|
|
if self._element.get("azimuth") is not None:
|
|
dest.azimuth = self.azimuth
|
|
if self._element.get("dip") is not None:
|
|
dest.dip = self.dip
|
|
if self._element.get("gain") is not None:
|
|
dest.gain = self.gain
|
|
if self._element.get("gainFrequency") is not None:
|
|
dest.gainFrequency = self.gainFrequency
|
|
if self._element.get("gainUnit") is not None:
|
|
dest.gainUnit = self.gainUnit
|
|
if self._element.get("format") is not None:
|
|
dest.format = self.format
|
|
if self._element.get("flags") is not None:
|
|
dest.flags = self.flags
|
|
if self._element.get("restricted") is not None:
|
|
dest.restricted = self.restricted
|
|
if self._element.get("shared") is not None:
|
|
dest.shared = self.shared
|
|
if self._element.get("publicID") is not None:
|
|
dest.publicID = self.publicID
|
|
|
|
@Property
|
|
def publicID():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("publicID"))
|
|
def fset(self, value):
|
|
self._element.set("publicID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def code():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("code"))
|
|
def fset(self, value):
|
|
self._element.set("code", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def start():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("start"))
|
|
def fset(self, value):
|
|
self._element.set("start", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def end():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("end"))
|
|
def fset(self, value):
|
|
self._element.set("end", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def datalogger():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("datalogger"))
|
|
def fset(self, value):
|
|
self._element.set("datalogger", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def dataloggerSerialNumber():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("dataloggerSerialNumber"))
|
|
def fset(self, value):
|
|
self._element.set("dataloggerSerialNumber", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def dataloggerChannel():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("dataloggerChannel"))
|
|
def fset(self, value):
|
|
self._element.set("dataloggerChannel", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def sensor():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("sensor"))
|
|
def fset(self, value):
|
|
self._element.set("sensor", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def sensorSerialNumber():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("sensorSerialNumber"))
|
|
def fset(self, value):
|
|
self._element.set("sensorSerialNumber", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def sensorChannel():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("sensorChannel"))
|
|
def fset(self, value):
|
|
self._element.set("sensorChannel", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def clockSerialNumber():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("clockSerialNumber"))
|
|
def fset(self, value):
|
|
self._element.set("clockSerialNumber", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def sampleRateNumerator():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("sampleRateNumerator"))
|
|
def fset(self, value):
|
|
self._element.set("sampleRateNumerator", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def sampleRateDenominator():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("sampleRateDenominator"))
|
|
def fset(self, value):
|
|
self._element.set("sampleRateDenominator", _int_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def depth():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("depth"))
|
|
def fset(self, value):
|
|
self._element.set("depth", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def azimuth():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("azimuth"))
|
|
def fset(self, value):
|
|
self._element.set("azimuth", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def dip():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("dip"))
|
|
def fset(self, value):
|
|
self._element.set("dip", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def gain():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("gain"))
|
|
def fset(self, value):
|
|
self._element.set("gain", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def gainFrequency():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("gainFrequency"))
|
|
def fset(self, value):
|
|
self._element.set("gainFrequency", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def gainUnit():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("gainUnit"))
|
|
def fset(self, value):
|
|
self._element.set("gainUnit", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def format():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("format"))
|
|
def fset(self, value):
|
|
self._element.set("format", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def flags():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("flags"))
|
|
def fset(self, value):
|
|
self._element.set("flags", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def restricted():
|
|
# type: boolean
|
|
def fget(self):
|
|
return _boolean_fromxml(self._element.get("restricted"))
|
|
def fset(self, value):
|
|
self._element.set("restricted", _boolean_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def shared():
|
|
# type: boolean
|
|
def fget(self):
|
|
return _boolean_fromxml(self._element.get("shared"))
|
|
def fset(self, value):
|
|
self._element.set("shared", _boolean_toxml(value))
|
|
return locals()
|
|
|
|
# Aggregation: Comment
|
|
def _new_comment(self):
|
|
return xml_Comment(ET.Element(xml_Comment._xmlns + "comment"))
|
|
@property
|
|
def comment(self):
|
|
for e1 in self._element.findall(xml_Comment._xmlns + "comment"):
|
|
yield xml_Comment(e1)
|
|
|
|
|
|
# Inventory::SensorLocation
|
|
class xml_SensorLocation(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_SensorLocation._xmlns + "sensorLocation")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.code = src.code
|
|
self.start = src.start
|
|
self.end = src.end
|
|
self.latitude = src.latitude
|
|
self.longitude = src.longitude
|
|
self.elevation = src.elevation
|
|
self.publicID = src.publicID
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("code") is not None:
|
|
dest.code = self.code
|
|
if self._element.get("start") is not None:
|
|
dest.start = self.start
|
|
if self._element.get("end") is not None:
|
|
dest.end = self.end
|
|
if self._element.get("latitude") is not None:
|
|
dest.latitude = self.latitude
|
|
if self._element.get("longitude") is not None:
|
|
dest.longitude = self.longitude
|
|
if self._element.get("elevation") is not None:
|
|
dest.elevation = self.elevation
|
|
if self._element.get("publicID") is not None:
|
|
dest.publicID = self.publicID
|
|
|
|
@Property
|
|
def publicID():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("publicID"))
|
|
def fset(self, value):
|
|
self._element.set("publicID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def code():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("code"))
|
|
def fset(self, value):
|
|
self._element.set("code", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def start():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("start"))
|
|
def fset(self, value):
|
|
self._element.set("start", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def end():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("end"))
|
|
def fset(self, value):
|
|
self._element.set("end", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def latitude():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("latitude"))
|
|
def fset(self, value):
|
|
self._element.set("latitude", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def longitude():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("longitude"))
|
|
def fset(self, value):
|
|
self._element.set("longitude", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def elevation():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("elevation"))
|
|
def fset(self, value):
|
|
self._element.set("elevation", _float_toxml(value))
|
|
return locals()
|
|
|
|
# Aggregation: Comment
|
|
def _new_comment(self):
|
|
return xml_Comment(ET.Element(xml_Comment._xmlns + "comment"))
|
|
@property
|
|
def comment(self):
|
|
for e1 in self._element.findall(xml_Comment._xmlns + "comment"):
|
|
yield xml_Comment(e1)
|
|
|
|
# Aggregation: AuxStream
|
|
def _new_auxStream(self):
|
|
return xml_AuxStream(ET.Element(xml_AuxStream._xmlns + "auxStream"))
|
|
@property
|
|
def auxStream(self):
|
|
for e1 in self._element.findall(xml_AuxStream._xmlns + "auxStream"):
|
|
yield xml_AuxStream(e1)
|
|
|
|
# Aggregation: Stream
|
|
def _new_stream(self):
|
|
return xml_Stream(ET.Element(xml_Stream._xmlns + "stream"))
|
|
@property
|
|
def stream(self):
|
|
for e1 in self._element.findall(xml_Stream._xmlns + "stream"):
|
|
yield xml_Stream(e1)
|
|
|
|
|
|
# Inventory::Station
|
|
class xml_Station(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_Station._xmlns + "station")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.code = src.code
|
|
self.start = src.start
|
|
self.end = src.end
|
|
self.description = src.description
|
|
self.latitude = src.latitude
|
|
self.longitude = src.longitude
|
|
self.elevation = src.elevation
|
|
self.place = src.place
|
|
self.country = src.country
|
|
self.affiliation = src.affiliation
|
|
self.type = src.type
|
|
self.archive = src.archive
|
|
self.archiveNetworkCode = src.archiveNetworkCode
|
|
self.restricted = src.restricted
|
|
self.shared = src.shared
|
|
self.remark = src.remark
|
|
self.publicID = src.publicID
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("code") is not None:
|
|
dest.code = self.code
|
|
if self._element.get("start") is not None:
|
|
dest.start = self.start
|
|
if self._element.get("end") is not None:
|
|
dest.end = self.end
|
|
if self._element.get("description") is not None:
|
|
dest.description = self.description
|
|
if self._element.get("latitude") is not None:
|
|
dest.latitude = self.latitude
|
|
if self._element.get("longitude") is not None:
|
|
dest.longitude = self.longitude
|
|
if self._element.get("elevation") is not None:
|
|
dest.elevation = self.elevation
|
|
if self._element.get("place") is not None:
|
|
dest.place = self.place
|
|
if self._element.get("country") is not None:
|
|
dest.country = self.country
|
|
if self._element.get("affiliation") is not None:
|
|
dest.affiliation = self.affiliation
|
|
if self._element.get("type") is not None:
|
|
dest.type = self.type
|
|
if self._element.get("archive") is not None:
|
|
dest.archive = self.archive
|
|
if self._element.get("archiveNetworkCode") is not None:
|
|
dest.archiveNetworkCode = self.archiveNetworkCode
|
|
if self._element.get("restricted") is not None:
|
|
dest.restricted = self.restricted
|
|
if self._element.get("shared") is not None:
|
|
dest.shared = self.shared
|
|
if self._element.find(xml_Station._xmlns + "remark") is not None:
|
|
dest.remark = self.remark
|
|
if self._element.get("publicID") is not None:
|
|
dest.publicID = self.publicID
|
|
|
|
@Property
|
|
def publicID():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("publicID"))
|
|
def fset(self, value):
|
|
self._element.set("publicID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def code():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("code"))
|
|
def fset(self, value):
|
|
self._element.set("code", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def start():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("start"))
|
|
def fset(self, value):
|
|
self._element.set("start", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def end():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("end"))
|
|
def fset(self, value):
|
|
self._element.set("end", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def description():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("description"))
|
|
def fset(self, value):
|
|
self._element.set("description", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def latitude():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("latitude"))
|
|
def fset(self, value):
|
|
self._element.set("latitude", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def longitude():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("longitude"))
|
|
def fset(self, value):
|
|
self._element.set("longitude", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def elevation():
|
|
# type: float
|
|
def fget(self):
|
|
return _float_fromxml(self._element.get("elevation"))
|
|
def fset(self, value):
|
|
self._element.set("elevation", _float_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def place():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("place"))
|
|
def fset(self, value):
|
|
self._element.set("place", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def country():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("country"))
|
|
def fset(self, value):
|
|
self._element.set("country", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def affiliation():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("affiliation"))
|
|
def fset(self, value):
|
|
self._element.set("affiliation", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def type():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("type"))
|
|
def fset(self, value):
|
|
self._element.set("type", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def archive():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("archive"))
|
|
def fset(self, value):
|
|
self._element.set("archive", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def archiveNetworkCode():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("archiveNetworkCode"))
|
|
def fset(self, value):
|
|
self._element.set("archiveNetworkCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def restricted():
|
|
# type: boolean
|
|
def fget(self):
|
|
return _boolean_fromxml(self._element.get("restricted"))
|
|
def fset(self, value):
|
|
self._element.set("restricted", _boolean_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def shared():
|
|
# type: boolean
|
|
def fget(self):
|
|
return _boolean_fromxml(self._element.get("shared"))
|
|
def fset(self, value):
|
|
self._element.set("shared", _boolean_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def remark():
|
|
# type: Blob
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_Station._xmlns + "remark")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_Station._xmlns + "remark", value)
|
|
return locals()
|
|
|
|
# Aggregation: Comment
|
|
def _new_comment(self):
|
|
return xml_Comment(ET.Element(xml_Comment._xmlns + "comment"))
|
|
@property
|
|
def comment(self):
|
|
for e1 in self._element.findall(xml_Comment._xmlns + "comment"):
|
|
yield xml_Comment(e1)
|
|
|
|
# Aggregation: SensorLocation
|
|
def _new_sensorLocation(self):
|
|
return xml_SensorLocation(ET.Element(xml_SensorLocation._xmlns + "sensorLocation"))
|
|
@property
|
|
def sensorLocation(self):
|
|
for e1 in self._element.findall(xml_SensorLocation._xmlns + "sensorLocation"):
|
|
yield xml_SensorLocation(e1)
|
|
|
|
|
|
# Inventory::Network
|
|
class xml_Network(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_Network._xmlns + "network")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.code = src.code
|
|
self.start = src.start
|
|
self.end = src.end
|
|
self.description = src.description
|
|
self.institutions = src.institutions
|
|
self.region = src.region
|
|
self.type = src.type
|
|
self.netClass = src.netClass
|
|
self.archive = src.archive
|
|
self.restricted = src.restricted
|
|
self.shared = src.shared
|
|
self.remark = src.remark
|
|
self.publicID = src.publicID
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("code") is not None:
|
|
dest.code = self.code
|
|
if self._element.get("start") is not None:
|
|
dest.start = self.start
|
|
if self._element.get("end") is not None:
|
|
dest.end = self.end
|
|
if self._element.get("description") is not None:
|
|
dest.description = self.description
|
|
if self._element.get("institutions") is not None:
|
|
dest.institutions = self.institutions
|
|
if self._element.get("region") is not None:
|
|
dest.region = self.region
|
|
if self._element.get("type") is not None:
|
|
dest.type = self.type
|
|
if self._element.get("netClass") is not None:
|
|
dest.netClass = self.netClass
|
|
if self._element.get("archive") is not None:
|
|
dest.archive = self.archive
|
|
if self._element.get("restricted") is not None:
|
|
dest.restricted = self.restricted
|
|
if self._element.get("shared") is not None:
|
|
dest.shared = self.shared
|
|
if self._element.find(xml_Network._xmlns + "remark") is not None:
|
|
dest.remark = self.remark
|
|
if self._element.get("publicID") is not None:
|
|
dest.publicID = self.publicID
|
|
|
|
@Property
|
|
def publicID():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("publicID"))
|
|
def fset(self, value):
|
|
self._element.set("publicID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def code():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("code"))
|
|
def fset(self, value):
|
|
self._element.set("code", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def start():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("start"))
|
|
def fset(self, value):
|
|
self._element.set("start", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def end():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("end"))
|
|
def fset(self, value):
|
|
self._element.set("end", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def description():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("description"))
|
|
def fset(self, value):
|
|
self._element.set("description", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def institutions():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("institutions"))
|
|
def fset(self, value):
|
|
self._element.set("institutions", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def region():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("region"))
|
|
def fset(self, value):
|
|
self._element.set("region", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def type():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("type"))
|
|
def fset(self, value):
|
|
self._element.set("type", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def netClass():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("netClass"))
|
|
def fset(self, value):
|
|
self._element.set("netClass", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def archive():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("archive"))
|
|
def fset(self, value):
|
|
self._element.set("archive", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def restricted():
|
|
# type: boolean
|
|
def fget(self):
|
|
return _boolean_fromxml(self._element.get("restricted"))
|
|
def fset(self, value):
|
|
self._element.set("restricted", _boolean_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def shared():
|
|
# type: boolean
|
|
def fget(self):
|
|
return _boolean_fromxml(self._element.get("shared"))
|
|
def fset(self, value):
|
|
self._element.set("shared", _boolean_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def remark():
|
|
# type: Blob
|
|
def fget(self):
|
|
return _get_blob(self._element, xml_Network._xmlns + "remark")
|
|
def fset(self, value):
|
|
_set_blob(self._element, xml_Network._xmlns + "remark", value)
|
|
return locals()
|
|
|
|
# Aggregation: Comment
|
|
def _new_comment(self):
|
|
return xml_Comment(ET.Element(xml_Comment._xmlns + "comment"))
|
|
@property
|
|
def comment(self):
|
|
for e1 in self._element.findall(xml_Comment._xmlns + "comment"):
|
|
yield xml_Comment(e1)
|
|
|
|
# Aggregation: Station
|
|
def _new_station(self):
|
|
return xml_Station(ET.Element(xml_Station._xmlns + "station"))
|
|
@property
|
|
def station(self):
|
|
for e1 in self._element.findall(xml_Station._xmlns + "station"):
|
|
yield xml_Station(e1)
|
|
|
|
|
|
# Inventory::Inventory
|
|
class xml_Inventory(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Inventory/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_Inventory._xmlns + "inventory")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
pass
|
|
|
|
|
|
def _copy_to(self, dest):
|
|
pass
|
|
|
|
@Property
|
|
def publicID():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("publicID"))
|
|
def fset(self, value):
|
|
self._element.set("publicID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
# Aggregation: StationGroup
|
|
def _new_stationGroup(self):
|
|
return xml_StationGroup(ET.Element(xml_StationGroup._xmlns + "stationGroup"))
|
|
@property
|
|
def stationGroup(self):
|
|
for e1 in self._element.findall(xml_StationGroup._xmlns + "stationGroup"):
|
|
yield xml_StationGroup(e1)
|
|
|
|
# Aggregation: AuxDevice
|
|
def _new_auxDevice(self):
|
|
return xml_AuxDevice(ET.Element(xml_AuxDevice._xmlns + "auxDevice"))
|
|
@property
|
|
def auxDevice(self):
|
|
for e1 in self._element.findall(xml_AuxDevice._xmlns + "auxDevice"):
|
|
yield xml_AuxDevice(e1)
|
|
|
|
# Aggregation: Sensor
|
|
def _new_sensor(self):
|
|
return xml_Sensor(ET.Element(xml_Sensor._xmlns + "sensor"))
|
|
@property
|
|
def sensor(self):
|
|
for e1 in self._element.findall(xml_Sensor._xmlns + "sensor"):
|
|
yield xml_Sensor(e1)
|
|
|
|
# Aggregation: Datalogger
|
|
def _new_datalogger(self):
|
|
return xml_Datalogger(ET.Element(xml_Datalogger._xmlns + "datalogger"))
|
|
@property
|
|
def datalogger(self):
|
|
for e1 in self._element.findall(xml_Datalogger._xmlns + "datalogger"):
|
|
yield xml_Datalogger(e1)
|
|
|
|
# Aggregation: ResponsePAZ
|
|
def _new_responsePAZ(self):
|
|
return xml_ResponsePAZ(ET.Element(xml_ResponsePAZ._xmlns + "responsePAZ"))
|
|
@property
|
|
def responsePAZ(self):
|
|
for e1 in self._element.findall(xml_ResponsePAZ._xmlns + "responsePAZ"):
|
|
yield xml_ResponsePAZ(e1)
|
|
|
|
# Aggregation: ResponseFIR
|
|
def _new_responseFIR(self):
|
|
return xml_ResponseFIR(ET.Element(xml_ResponseFIR._xmlns + "responseFIR"))
|
|
@property
|
|
def responseFIR(self):
|
|
for e1 in self._element.findall(xml_ResponseFIR._xmlns + "responseFIR"):
|
|
yield xml_ResponseFIR(e1)
|
|
|
|
# Aggregation: ResponseIIR
|
|
def _new_responseIIR(self):
|
|
return xml_ResponseIIR(ET.Element(xml_ResponseIIR._xmlns + "responseIIR"))
|
|
@property
|
|
def responseIIR(self):
|
|
for e1 in self._element.findall(xml_ResponseIIR._xmlns + "responseIIR"):
|
|
yield xml_ResponseIIR(e1)
|
|
|
|
# Aggregation: ResponsePolynomial
|
|
def _new_responsePolynomial(self):
|
|
return xml_ResponsePolynomial(ET.Element(xml_ResponsePolynomial._xmlns + "responsePolynomial"))
|
|
@property
|
|
def responsePolynomial(self):
|
|
for e1 in self._element.findall(xml_ResponsePolynomial._xmlns + "responsePolynomial"):
|
|
yield xml_ResponsePolynomial(e1)
|
|
|
|
# Aggregation: ResponseFAP
|
|
def _new_responseFAP(self):
|
|
return xml_ResponseFAP(ET.Element(xml_ResponseFAP._xmlns + "responseFAP"))
|
|
@property
|
|
def responseFAP(self):
|
|
for e1 in self._element.findall(xml_ResponseFAP._xmlns + "responseFAP"):
|
|
yield xml_ResponseFAP(e1)
|
|
|
|
# Aggregation: Network
|
|
def _new_network(self):
|
|
return xml_Network(ET.Element(xml_Network._xmlns + "network"))
|
|
@property
|
|
def network(self):
|
|
for e1 in self._element.findall(xml_Network._xmlns + "network"):
|
|
yield xml_Network(e1)
|
|
|
|
|
|
# Routing::RouteArclink
|
|
class xml_RouteArclink(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Routing/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_RouteArclink._xmlns + "routeArclink")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.address = src.address
|
|
self.start = src.start
|
|
self.end = src.end
|
|
self.priority = src.priority
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("address") is not None:
|
|
dest.address = self.address
|
|
if self._element.get("start") is not None:
|
|
dest.start = self.start
|
|
if self._element.get("end") is not None:
|
|
dest.end = self.end
|
|
if self._element.get("priority") is not None:
|
|
dest.priority = self.priority
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def address():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("address"))
|
|
def fset(self, value):
|
|
self._element.set("address", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def start():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("start"))
|
|
def fset(self, value):
|
|
self._element.set("start", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def end():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("end"))
|
|
def fset(self, value):
|
|
self._element.set("end", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def priority():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("priority"))
|
|
def fset(self, value):
|
|
self._element.set("priority", _int_toxml(value))
|
|
return locals()
|
|
|
|
|
|
# Routing::RouteSeedlink
|
|
class xml_RouteSeedlink(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Routing/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_RouteSeedlink._xmlns + "routeSeedlink")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.address = src.address
|
|
self.priority = src.priority
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("address") is not None:
|
|
dest.address = self.address
|
|
if self._element.get("priority") is not None:
|
|
dest.priority = self.priority
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def address():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("address"))
|
|
def fset(self, value):
|
|
self._element.set("address", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def priority():
|
|
# type: int
|
|
def fget(self):
|
|
return _int_fromxml(self._element.get("priority"))
|
|
def fset(self, value):
|
|
self._element.set("priority", _int_toxml(value))
|
|
return locals()
|
|
|
|
|
|
# Routing::Route
|
|
class xml_Route(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Routing/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_Route._xmlns + "route")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.networkCode = src.networkCode
|
|
self.stationCode = src.stationCode
|
|
self.locationCode = src.locationCode
|
|
self.streamCode = src.streamCode
|
|
self.publicID = src.publicID
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("networkCode") is not None:
|
|
dest.networkCode = self.networkCode
|
|
if self._element.get("stationCode") is not None:
|
|
dest.stationCode = self.stationCode
|
|
if self._element.get("locationCode") is not None:
|
|
dest.locationCode = self.locationCode
|
|
if self._element.get("streamCode") is not None:
|
|
dest.streamCode = self.streamCode
|
|
if self._element.get("publicID") is not None:
|
|
dest.publicID = self.publicID
|
|
|
|
@Property
|
|
def publicID():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("publicID"))
|
|
def fset(self, value):
|
|
self._element.set("publicID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def networkCode():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("networkCode"))
|
|
def fset(self, value):
|
|
self._element.set("networkCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def stationCode():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("stationCode"))
|
|
def fset(self, value):
|
|
self._element.set("stationCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def locationCode():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("locationCode"))
|
|
def fset(self, value):
|
|
self._element.set("locationCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def streamCode():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("streamCode"))
|
|
def fset(self, value):
|
|
self._element.set("streamCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
# Aggregation: RouteArclink
|
|
def _new_arclink(self):
|
|
return xml_RouteArclink(ET.Element(xml_RouteArclink._xmlns + "arclink"))
|
|
@property
|
|
def arclink(self):
|
|
for e1 in self._element.findall(xml_RouteArclink._xmlns + "arclink"):
|
|
yield xml_RouteArclink(e1)
|
|
|
|
# Aggregation: RouteSeedlink
|
|
def _new_seedlink(self):
|
|
return xml_RouteSeedlink(ET.Element(xml_RouteSeedlink._xmlns + "seedlink"))
|
|
@property
|
|
def seedlink(self):
|
|
for e1 in self._element.findall(xml_RouteSeedlink._xmlns + "seedlink"):
|
|
yield xml_RouteSeedlink(e1)
|
|
|
|
|
|
# Routing::Access
|
|
class xml_Access(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Routing/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_Access._xmlns + "access")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
self.networkCode = src.networkCode
|
|
self.stationCode = src.stationCode
|
|
self.locationCode = src.locationCode
|
|
self.streamCode = src.streamCode
|
|
self.user = src.user
|
|
self.start = src.start
|
|
self.end = src.end
|
|
|
|
def _copy_to(self, dest):
|
|
if self._element.get("networkCode") is not None:
|
|
dest.networkCode = self.networkCode
|
|
if self._element.get("stationCode") is not None:
|
|
dest.stationCode = self.stationCode
|
|
if self._element.get("locationCode") is not None:
|
|
dest.locationCode = self.locationCode
|
|
if self._element.get("streamCode") is not None:
|
|
dest.streamCode = self.streamCode
|
|
if self._element.get("user") is not None:
|
|
dest.user = self.user
|
|
if self._element.get("start") is not None:
|
|
dest.start = self.start
|
|
if self._element.get("end") is not None:
|
|
dest.end = self.end
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def networkCode():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("networkCode"))
|
|
def fset(self, value):
|
|
self._element.set("networkCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def stationCode():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("stationCode"))
|
|
def fset(self, value):
|
|
self._element.set("stationCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def locationCode():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("locationCode"))
|
|
def fset(self, value):
|
|
self._element.set("locationCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def streamCode():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("streamCode"))
|
|
def fset(self, value):
|
|
self._element.set("streamCode", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def user():
|
|
# type: string
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("user"))
|
|
def fset(self, value):
|
|
self._element.set("user", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def start():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("start"))
|
|
def fset(self, value):
|
|
self._element.set("start", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def end():
|
|
# type: datetime
|
|
def fget(self):
|
|
return _datetime_fromxml(self._element.get("end"))
|
|
def fset(self, value):
|
|
self._element.set("end", _datetime_toxml(value))
|
|
return locals()
|
|
|
|
|
|
# Routing::Routing
|
|
class xml_Routing(object):
|
|
_xmlns = "{http://geofon.gfz-potsdam.de/ns/Routing/1.0/}"
|
|
def __init__(self, e = None):
|
|
if e is None:
|
|
self._element = ET.Element(xml_Routing._xmlns + "routing")
|
|
else:
|
|
self._element = e
|
|
|
|
def _append_child(self, obj):
|
|
self._element.append(obj._element)
|
|
|
|
def _copy_from(self, src):
|
|
pass
|
|
|
|
|
|
def _copy_to(self, dest):
|
|
pass
|
|
|
|
@Property
|
|
def publicID():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("publicID"))
|
|
def fset(self, value):
|
|
self._element.set("publicID", _string_toxml(value))
|
|
return locals()
|
|
|
|
@Property
|
|
def action():
|
|
def fget(self):
|
|
return _string_fromxml(self._element.get("action"))
|
|
def fset(self, value):
|
|
self._element.set("action", _string_toxml(value))
|
|
return locals()
|
|
|
|
# Aggregation: Route
|
|
def _new_route(self):
|
|
return xml_Route(ET.Element(xml_Route._xmlns + "route"))
|
|
@property
|
|
def route(self):
|
|
for e1 in self._element.findall(xml_Route._xmlns + "route"):
|
|
yield xml_Route(e1)
|
|
|
|
# Aggregation: Access
|
|
def _new_access(self):
|
|
return xml_Access(ET.Element(xml_Access._xmlns + "access"))
|
|
@property
|
|
def access(self):
|
|
for e1 in self._element.findall(xml_Access._xmlns + "access"):
|
|
yield xml_Access(e1)
|