def _extract(self, raw: str, station: str = None) -> "str|[str]":
"""
Extracts the raw_report element from XML response
"""
resp = parsexml(raw)
try:
data = resp["response"]["data"]
if data["@num_results"] == "0":
return ""
reports = data[self._targets[self.rtype]]
except KeyError:
raise self._make_err(raw)
# Only one report exists
if isinstance(reports, dict):
ret = reports["raw_text"]
if self.rtype in self._coallate:
ret = [ret]
# Multiple reports exist
elif isinstance(reports, list) and reports:
if self.rtype in self._coallate:
ret = [r["raw_text"] for r in reports]
else:
ret = reports[0]["raw_text"]
# Something went wrong
else:
raise self._make_err(raw, '"raw_text"')
return ret
def get_metar_info(self):
"""Queries the NOAA METAR service."""
metars = {}
# NOAA can only handle so much at once, so split into chunks.
# Even though we can issue larger chunk sizes, sometimes data is missing from the returned
# results. Smaller chunks seem to help...
for chunk in chunks(self.airport_codes, 250):
self.url = self.URL.format(airport_codes=','.join(chunk),
subdomain=self.subdomain)
response = self._query()
try:
response = parsexml(response.text)['response']['data']['METAR']
if not isinstance(response, list):
response = [response]
except: # noqa
log.exception('Metar response is invalid.')
raise
finally:
# ...but with more requests, we should be nice and wait a bit before the next
time.sleep(1.0)
for m in response:
metars[m['station_id'].upper()] = m
return metars
def _extract(self, raw: str, station: str = None) -> 'str|[str]':
"""
Extracts the raw_report element from XML response
"""
resp = parsexml(raw)
try:
data = resp['response']['data']
if data['@num_results'] == '0':
return ''
reports = data[self._targets[self.rtype]]
except KeyError:
raise self.make_err(raw)
# Only one report exists
if isinstance(reports, dict):
ret = self._report_strip(reports['raw_text'])
if self.rtype in self._coallate:
ret = [ret]
# Multiple reports exist
elif isinstance(reports, list) and reports:
if self.rtype in self._coallate:
ret = [self._report_strip(r['raw_text']) for r in reports]
else:
ret = self._report_strip(reports[0]['raw_text'])
# Something went wrong
else:
raise self.make_err(raw, '"raw_text"')
return ret
def _extract(self, raw: str, station: str = None) -> str:
"""
Extracts the raw_report element from XML response
"""
LOGGER.debug('%s: %s: extracting report from XML data',
self.__class__.__name__, station)
resp = parsexml(raw)
LOGGER.debug('%s: %s: extraction successful', self.__class__.__name__,
station)
try:
report = resp['response']['data'][self.rtype.upper()]
except KeyError:
raise self.make_err(raw)
# Find report string
if isinstance(report, dict):
LOGGER.debug('%s: %s: received a single report',
self.__class__.__name__, station)
report = report['raw_text']
elif isinstance(report, list) and report:
LOGGER.debug('%s: %s: received %s reports, using first one',
self.__class__.__name__, station, len(report))
report = report[0]['raw_text']
else:
raise self.make_err(raw, '"raw_text"')
# Remove excess leading and trailing data
LOGGER.debug('%s: %s: stripping extra data', self.__class__.__name__,
station)
for item in (self.rtype.upper(), 'SPECI'):
if report.startswith(item + ' '):
report = report[len(item) + 1:]
LOGGER.debug('%s: %s: returning report: %s', self.__class__.__name__,
station, report)
return report
def _extract(self, raw: str, station: str = None) -> 'str|[str]':
"""
Extracts the raw_report element from XML response
"""
resp = parsexml(raw)
try:
data = resp['response']['data']
if data['@num_results'] == '0':
return ''
reports = data[self._targets[self.rtype]]
except KeyError:
raise self.make_err(raw)
# Only one report exists
if isinstance(reports, dict):
ret = self._report_strip(reports['raw_text'])
if self.rtype in self._coallate:
ret = [ret]
# Multiple reports exist
elif isinstance(reports, list) and reports:
if self.rtype in self._coallate:
ret = [self._report_strip(r['raw_text']) for r in reports]
else:
ret = self._report_strip(reports[0]['raw_text'])
# Something went wrong
else:
raise self.make_err(raw, '"raw_text"')
return ret
def _extract(self, report_type: str, text: str) -> list[str]:
"""Extracts the raw_report element from XML response"""
resp = parsexml(text)
try:
data = resp["response"]["data"]
if data["@num_results"] == "0":
return ""
reports = data[self._targets[report_type]]
except KeyError as key_error:
raise InvalidRequest(
"Could not find report path in response") from key_error
target = "station_id" if report_type == "station" else "raw_text"
return list({r[target] for r in reports})
def _extract(self, raw: str) -> str:
"""
Extracts the raw_report element from XML response
"""
resp = parsexml(raw)
try:
report = resp['response']['data'][self.rtype.upper()]
except:
raise self.make_err(raw)
if isinstance(report, dict):
return report['raw_text']
elif isinstance(report, list) and report:
return report[0]['raw_text']
else:
raise self.make_err(raw, '"raw_text"')
def fetch_info(stream):
url = build_url(stream.ingest_host, reverse("stream-info"))
r = requests.get(url, headers=build_headers())
r.raise_for_status()
info = parsexml(r.text)
for app in info["rtmp"]["server"]["application"]:
if app["name"] == "app" and "live" in app and "stream" in app["live"]:
if hasattr(app["live"]["stream"], "items"):
streams = [app["live"]["stream"]]
else:
streams = app["live"]["stream"]
for s in streams:
if s["name"] == str(stream.uuid):
return s
def _extract(self, raw: str) -> str:
"""
Extracts the report message from XML response
"""
resp = parsexml(raw)
try:
report = resp['response']['body']['items']['item'][self.rtype.lower() + 'Msg']
except:
raise self.make_err(raw)
# Replace line breaks
report = report.replace('\n', '')
# Remove excess leading and trailing data
report = report.lstrip(self.rtype.upper()).rstrip('=')
# Make every element single-spaced and stripped
return ' '.join(report.split())
def _extract(self, raw: str, station: str = None) -> str:
"""
Extracts the report message from XML response
"""
resp = parsexml(raw)
try:
report = resp['response']['body']['items']['item'][self.rtype.lower() + 'Msg']
except KeyError:
raise self.make_err(raw)
# Replace line breaks
report = report.replace('\n', '')
# Remove excess leading and trailing data
for item in (self.rtype.upper(), 'SPECI'):
if report.startswith(item + ' '):
report = report[len(item)+1:]
report = report.rstrip('=')
# Make every element single-spaced and stripped
return ' '.join(report.split())
def _extract(self, raw: str, station: str = None) -> str:
"""
Extracts the report message from XML response
"""
resp = parsexml(raw)
try:
report = resp['response']['body']['items']['item'][self.rtype.lower() + 'Msg']
except KeyError:
raise self.make_err(raw)
# Replace line breaks
report = report.replace('\n', '')
# Remove excess leading and trailing data
for item in (self.rtype.upper(), 'SPECI'):
if report.startswith(item + ' '):
report = report[len(item)+1:]
report = report.rstrip('=')
# Make every element single-spaced and stripped
return ' '.join(report.split())
def _run_cmd(command, args=[]):
"""
Helper function to help calling and decoding ipset output
:param command: command to run
:param args: list of additional arguments
:return: tuple (bool, dict, str), representing command success, parsed output, and raw error output
"""
result = run(["ipset", command, "-output", "xml"] + args,
stdout=PIPE,
stderr=PIPE,
timeout=2)
success = result.returncode == 0
out = result.stdout.decode("UTF-8")
err = result.stderr.decode("UTF-8")
if out:
return (success, parsexml(out), err or None)
else:
return (success, None, err or None)
def _extract(self, raw: str, station: str = None) -> str:
"""Extracts the report message from XML response"""
resp = parsexml(raw)
try:
report = resp["response"]["body"]["items"]["item"][
self.report_type.lower() + "Msg"]
except KeyError as key_error:
raise self._make_err(raw) from key_error
if not report:
raise self._make_err("The station might not exist")
# Replace line breaks
report = report.replace("\n", "")
# Remove excess leading and trailing data
for item in (self.report_type.upper(), "SPECI"):
if report.startswith(item + " "):
report = report[len(item) + 1:]
report = report.rstrip("=")
# Make every element single-spaced and stripped
return " ".join(report.split())
def _extract(self, raw: str, station: str = None) -> str:
"""
Extracts the raw_report element from XML response
"""
resp = parsexml(raw)
try:
report = resp['response']['data'][self.rtype.upper()]
except KeyError:
raise self.make_err(raw)
# Find report string
if isinstance(report, dict):
report = report['raw_text']
elif isinstance(report, list) and report:
report = report[0]['raw_text']
else:
raise self.make_err(raw, '"raw_text"')
# Remove excess leading and trailing data
for item in (self.rtype.upper(), 'SPECI'):
if report.startswith(item + ' '):
report = report[len(item)+1:]
return report
