INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Provides a select box for country selection | def area_field(key='area'):
"""Provides a select box for country selection"""
area_list = list(subdivisions)
title_map = []
for item in area_list:
title_map.append({'value': item.code, 'name': item.name})
widget = {
'key': key,
'type': 'uiselect',
'titleMap': title_... |
Tests internet connectivity in regular intervals and updates the nodestate accordingly | def timed_connectivity_check(self, event):
"""Tests internet connectivity in regular intervals and updates the nodestate accordingly"""
self.status = self._can_connect()
self.log('Timed connectivity check:', self.status, lvl=verbose)
if self.status:
if not self.old_status:
... |
Tries to connect to the configured host: port and returns True if the connection was established | def _can_connect(self):
"""Tries to connect to the configured host:port and returns True if the connection was established"""
self.log('Trying to reach configured connectivity check endpoint', lvl=verbose)
try:
socket.setdefaulttimeout(self.config.timeout)
socket.socket(... |
Handles navigational reference frame updates. These are necessary to assign geo coordinates to alerts and other misc things. | def referenceframe(self, event):
"""Handles navigational reference frame updates.
These are necessary to assign geo coordinates to alerts and other
misc things.
:param event with incoming referenceframe message
"""
self.log("Got a reference frame update! ", event, lvl=v... |
ActivityMonitor event handler for incoming events | def activityrequest(self, event):
"""ActivityMonitor event handler for incoming events
:param event with incoming ActivityMonitor message
"""
# self.log("Event: '%s'" % event.__dict__)
try:
action = event.action
data = event.data
self.log("A... |
Modify field values of objects | def modify(ctx, schema, uuid, object_filter, field, value):
"""Modify field values of objects"""
database = ctx.obj['db']
model = database.objectmodels[schema]
obj = None
if uuid:
obj = model.find_one({'uuid': uuid})
elif object_filter:
obj = model.find_one(literal_eval(object_... |
Show stored objects | def view(ctx, schema, uuid, object_filter):
"""Show stored objects"""
database = ctx.obj['db']
if schema is None:
log('No schema given. Read the help', lvl=warn)
return
model = database.objectmodels[schema]
if uuid:
obj = model.find({'uuid': uuid})
elif object_filter:... |
Delete stored objects ( CAUTION! ) | def delete(ctx, schema, uuid, object_filter, yes):
"""Delete stored objects (CAUTION!)"""
database = ctx.obj['db']
if schema is None:
log('No schema given. Read the help', lvl=warn)
return
model = database.objectmodels[schema]
if uuid:
count = model.count({'uuid': uuid})
... |
Validates all objects or all objects of a given schema. | def validate(ctx, schema, all_schemata):
"""Validates all objects or all objects of a given schema."""
database = ctx.obj['db']
if schema is None:
if all_schemata is False:
log('No schema given. Read the help', lvl=warn)
return
else:
schemata = database.... |
Find fields in registered data models. | def find_field(ctx, search, by_type, obj):
"""Find fields in registered data models."""
# TODO: Fix this to work recursively on all possible subschemes
if search is not None:
search = search
else:
search = _ask("Enter search term")
database = ctx.obj['db']
def find(search_sche... |
Get distance between pairs of lat - lon points | def Distance(lat1, lon1, lat2, lon2):
"""Get distance between pairs of lat-lon points"""
az12, az21, dist = wgs84_geod.inv(lon1, lat1, lon2, lat2)
return az21, dist |
Display known details about a given client | def client_details(self, *args):
"""Display known details about a given client"""
self.log(_('Client details:', lang='de'))
client = self._clients[args[0]]
self.log('UUID:', client.uuid, 'IP:', client.ip, 'Name:', client.name, 'User:', self._users[client.useruuid],
pre... |
Display a list of connected clients | def client_list(self, *args):
"""Display a list of connected clients"""
if len(self._clients) == 0:
self.log('No clients connected')
else:
self.log(self._clients, pretty=True) |
Display a list of connected users | def users_list(self, *args):
"""Display a list of connected users"""
if len(self._users) == 0:
self.log('No users connected')
else:
self.log(self._users, pretty=True) |
Display a list of all registered events | def sourcess_list(self, *args):
"""Display a list of all registered events"""
from pprint import pprint
sources = {}
sources.update(self.authorized_events)
sources.update(self.anonymous_events)
for source in sources:
pprint(source) |
Display a list of all registered events | def events_list(self, *args):
"""Display a list of all registered events"""
def merge(a, b, path=None):
"merges b into a"
if path is None: path = []
for key in b:
if key in a:
if isinstance(a[key], dict) and isinstance(b[key], dict... |
Display a table of connected users and clients | def who(self, *args):
"""Display a table of connected users and clients"""
if len(self._users) == 0:
self.log('No users connected')
if len(self._clients) == 0:
self.log('No clients connected')
return
Row = namedtuple("Row", ['User', 'Clien... |
Handles socket disconnections | def disconnect(self, sock):
"""Handles socket disconnections"""
self.log("Disconnect ", sock, lvl=debug)
try:
if sock in self._sockets:
self.log("Getting socket", lvl=debug)
sockobj = self._sockets[sock]
self.log("Getting clientuuid",... |
Log out a client and possibly associated user | def _logoutclient(self, useruuid, clientuuid):
"""Log out a client and possibly associated user"""
self.log("Cleaning up client of logged in user.", lvl=debug)
try:
self._users[useruuid].clients.remove(clientuuid)
if len(self._users[useruuid].clients) == 0:
... |
Registers new sockets and their clients and allocates uuids | def connect(self, *args):
"""Registers new sockets and their clients and allocates uuids"""
self.log("Connect ", args, lvl=verbose)
try:
sock = args[0]
ip = args[1]
if sock not in self._sockets:
self.log("New client connected:", ip, lvl=debu... |
Sends a packet to an already known user or one of his clients by UUID | def send(self, event):
"""Sends a packet to an already known user or one of his clients by
UUID"""
try:
jsonpacket = json.dumps(event.packet, cls=ComplexEncoder)
if event.sendtype == "user":
# TODO: I think, caching a user name <-> uuid table would
... |
Broadcasts an event either to all users or clients depending on event flag | def broadcast(self, event):
"""Broadcasts an event either to all users or clients, depending on
event flag"""
try:
if event.broadcasttype == "users":
if len(self._users) > 0:
self.log("Broadcasting to all users:",
event... |
Checks if the user has in any role that allows to fire the event. | def _checkPermissions(self, user, event):
"""Checks if the user has in any role that allows to fire the event."""
for role in user.account.roles:
if role in event.roles:
self.log('Access granted', lvl=verbose)
return True
self.log('Access denied', lv... |
Isolated communication link for authorized events. | def _handleAuthorizedEvents(self, component, action, data, user, client):
"""Isolated communication link for authorized events."""
try:
if component == "debugger":
self.log(component, action, data, user, client, lvl=info)
if not user and component in self.author... |
Handler for anonymous ( public ) events | def _handleAnonymousEvents(self, component, action, data, client):
"""Handler for anonymous (public) events"""
try:
event = self.anonymous_events[component][action]['event']
self.log("Firing anonymous event: ", component, action,
str(data)[:20], lvl=network)... |
Handler for authentication events | def _handleAuthenticationEvents(self, requestdata, requestaction,
clientuuid, sock):
"""Handler for authentication events"""
# TODO: Move this stuff over to ./auth.py
if requestaction in ("login", "autologin"):
try:
self.log("Login... |
Resets the list of flood offenders on event trigger | def _reset_flood_offenders(self, *args):
"""Resets the list of flood offenders on event trigger"""
offenders = []
# self.log('Resetting flood offenders')
for offender, offence_time in self._flooding.items():
if time() - offence_time < 10:
self.log('Removed o... |
Checks if any clients have been flooding the node | def _check_flood_protection(self, component, action, clientuuid):
"""Checks if any clients have been flooding the node"""
if clientuuid not in self._flood_counter:
self._flood_counter[clientuuid] = 0
self._flood_counter[clientuuid] += 1
if self._flood_counter[clientuuid] >... |
Handles raw client requests and distributes them to the appropriate components | def read(self, *args):
"""Handles raw client requests and distributes them to the
appropriate components"""
self.log("Beginning new transaction: ", args, lvl=network)
try:
sock, msg = args[0], args[1]
user = password = client = clientuuid = useruuid = requestdata... |
Links the client to the granted account and profile then notifies the client | def authentication(self, event):
"""Links the client to the granted account and profile,
then notifies the client"""
try:
self.log("Authorization has been granted by DB check:",
event.username, lvl=debug)
account, profile, clientconfig = event.userd... |
Store client s selection of a new translation | def selectlanguage(self, event):
"""Store client's selection of a new translation"""
self.log('Language selection event:', event.client, pretty=True)
if event.data not in all_languages():
self.log('Unavailable language selected:', event.data, lvl=warn)
language = None
... |
Compile and return a human readable list of registered translations | def getlanguages(self, event):
"""Compile and return a human readable list of registered translations"""
self.log('Client requests all languages.', lvl=verbose)
result = {
'component': 'hfos.ui.clientmanager',
'action': 'getlanguages',
'data': language_token_... |
Perform a ping to measure client < - > node latency | def ping(self, event):
"""Perform a ping to measure client <-> node latency"""
self.log('Client ping received:', event.data, lvl=verbose)
response = {
'component': 'hfos.ui.clientmanager',
'action': 'pong',
'data': [event.data, time() * 1000]
}
... |
Converts between geodetic modified apex quasi - dipole and MLT. | def convert(self, lat, lon, source, dest, height=0, datetime=None,
precision=1e-10, ssheight=50*6371):
"""Converts between geodetic, modified apex, quasi-dipole and MLT.
Parameters
==========
lat : array_like
Latitude
lon : array_like
Long... |
Converts geodetic to modified apex coordinates. | def geo2apex(self, glat, glon, height):
"""Converts geodetic to modified apex coordinates.
Parameters
==========
glat : array_like
Geodetic latitude
glon : array_like
Geodetic longitude
height : array_like
Altitude in km
Retur... |
Converts modified apex to geodetic coordinates. | def apex2geo(self, alat, alon, height, precision=1e-10):
"""Converts modified apex to geodetic coordinates.
Parameters
==========
alat : array_like
Modified apex latitude
alon : array_like
Modified apex longitude
height : array_like
Al... |
Converts geodetic to quasi - dipole coordinates. | def geo2qd(self, glat, glon, height):
"""Converts geodetic to quasi-dipole coordinates.
Parameters
==========
glat : array_like
Geodetic latitude
glon : array_like
Geodetic longitude
height : array_like
Altitude in km
Returns
... |
Converts quasi - dipole to geodetic coordinates. | def qd2geo(self, qlat, qlon, height, precision=1e-10):
"""Converts quasi-dipole to geodetic coordinates.
Parameters
==========
qlat : array_like
Quasi-dipole latitude
qlon : array_like
Quasi-dipole longitude
height : array_like
Altitud... |
Convert from apex to quasi - dipole ( not - vectorised ) | def _apex2qd_nonvectorized(self, alat, alon, height):
"""Convert from apex to quasi-dipole (not-vectorised)
Parameters
-----------
alat : (float)
Apex latitude in degrees
alon : (float)
Apex longitude in degrees
height : (float)
Height... |
Converts modified apex to quasi - dipole coordinates. | def apex2qd(self, alat, alon, height):
"""Converts modified apex to quasi-dipole coordinates.
Parameters
==========
alat : array_like
Modified apex latitude
alon : array_like
Modified apex longitude
height : array_like
Altitude in km
... |
Converts quasi - dipole to modified apex coordinates. | def qd2apex(self, qlat, qlon, height):
"""Converts quasi-dipole to modified apex coordinates.
Parameters
==========
qlat : array_like
Quasi-dipole latitude
qlon : array_like
Quasi-dipole longitude
height : array_like
Altitude in km
... |
Computes the magnetic local time at the specified magnetic longitude and UT. | def mlon2mlt(self, mlon, datetime, ssheight=50*6371):
"""Computes the magnetic local time at the specified magnetic longitude
and UT.
Parameters
==========
mlon : array_like
Magnetic longitude (apex and quasi-dipole longitude are always
equal)
da... |
Computes the magnetic longitude at the specified magnetic local time and UT. | def mlt2mlon(self, mlt, datetime, ssheight=50*6371):
"""Computes the magnetic longitude at the specified magnetic local time
and UT.
Parameters
==========
mlt : array_like
Magnetic local time
datetime : :class:`datetime.datetime`
Date and time
... |
Performs mapping of points along the magnetic field to the closest or conjugate hemisphere. | def map_to_height(self, glat, glon, height, newheight, conjugate=False,
precision=1e-10):
"""Performs mapping of points along the magnetic field to the closest
or conjugate hemisphere.
Parameters
==========
glat : array_like
Geodetic latitude
... |
Performs mapping of electric field along the magnetic field. | def map_E_to_height(self, alat, alon, height, newheight, E):
"""Performs mapping of electric field along the magnetic field.
It is assumed that the electric field is perpendicular to B.
Parameters
==========
alat : (N,) array_like or float
Modified apex latitude
... |
Performs mapping of electric drift velocity along the magnetic field. | def map_V_to_height(self, alat, alon, height, newheight, V):
"""Performs mapping of electric drift velocity along the magnetic field.
It is assumed that the electric field is perpendicular to B.
Parameters
==========
alat : (N,) array_like or float
Modified apex lat... |
Returns quasi - dipole base vectors f1 and f2 at the specified coordinates. | def basevectors_qd(self, lat, lon, height, coords='geo', precision=1e-10):
"""Returns quasi-dipole base vectors f1 and f2 at the specified
coordinates.
The vectors are described by Richmond [1995] [2]_ and
Emmert et al. [2010] [3]_. The vector components are geodetic east and
n... |
Returns base vectors in quasi - dipole and apex coordinates. | def basevectors_apex(self, lat, lon, height, coords='geo', precision=1e-10):
"""Returns base vectors in quasi-dipole and apex coordinates.
The vectors are described by Richmond [1995] [4]_ and
Emmert et al. [2010] [5]_. The vector components are geodetic east,
north, and up (only east ... |
Calculate apex height | def get_apex(self, lat, height=None):
""" Calculate apex height
Parameters
-----------
lat : (float)
Latitude in degrees
height : (float or NoneType)
Height above the surface of the earth in km or NoneType to use
reference height (default=None... |
Updates the epoch for all subsequent conversions. | def set_epoch(self, year):
"""Updates the epoch for all subsequent conversions.
Parameters
==========
year : float
Decimal year
"""
fa.loadapxsh(self.datafile, np.float(year))
self.year = year |
Basic ordered parser. | def basic_parser(patterns, with_name=None):
""" Basic ordered parser.
"""
def parse(line):
output = None
highest_order = 0
highest_pattern_name = None
for pattern in patterns:
results = pattern.findall(line)
if results and any(results):
... |
This parser is able to handle multiple different patterns finding stuff in text -- while removing matches that overlap. | def alt_parser(patterns):
""" This parser is able to handle multiple different patterns
finding stuff in text-- while removing matches that overlap.
"""
from reparse.util import remove_lower_overlapping
get_first = lambda items: [i[0] for i in items]
get_second = lambda items: [i[1] for i in... |
This parser_type simply outputs an array of [ ( tree regex ) ] for use in another language. | def build_tree_parser(patterns):
""" This parser_type simply outputs an array of [(tree, regex)]
for use in another language.
"""
def output():
for pattern in patterns:
yield (pattern.build_full_tree(), pattern.regex)
return list(output()) |
A Reparse parser description. Simply provide the functions patterns & expressions to build. If you are using YAML for expressions + patterns you can use expressions_yaml_path & patterns_yaml_path for convenience. | def parser(parser_type=basic_parser, functions=None, patterns=None, expressions=None, patterns_yaml_path=None,
expressions_yaml_path=None):
""" A Reparse parser description.
Simply provide the functions, patterns, & expressions to build.
If you are using YAML for expressions + patterns, y... |
Translate KML file to geojson for import | def _translate(self, input_filename, output_filename):
"""Translate KML file to geojson for import"""
command = [
self.translate_binary,
'-f', 'GeoJSON',
output_filename,
input_filename
]
result = self._runcommand(command)
self.log... |
Update a single specified guide | def _update_guide(self, guide, update=False, clear=True):
"""Update a single specified guide"""
kml_filename = os.path.join(self.cache_path, guide + '.kml')
geojson_filename = os.path.join(self.cache_path, guide + '.geojson')
if not os.path.exists(geojson_filename) or update:
... |
Worker task to send out an email which is a blocking process unless it is threaded | def send_mail_worker(config, mail, event):
"""Worker task to send out an email, which is a blocking process unless it is threaded"""
log = ""
try:
if config.get('ssl', True):
server = SMTP_SSL(config['server'], port=config['port'], timeout=30)
else:
server = SMTP(con... |
Connect to mail server and send actual email | def send_mail(self, event):
"""Connect to mail server and send actual email"""
mime_mail = MIMEText(event.text)
mime_mail['Subject'] = event.subject
if event.account == 'default':
account_name = self.config.default_account
else:
account_name = event.acco... |
Provision a system user | def provision_system_user(items, database_name, overwrite=False, clear=False, skip_user_check=False):
"""Provision a system user"""
from hfos.provisions.base import provisionList
from hfos.database import objectmodels
# TODO: Add a root user and make sure owner can access it later.
# Setting up de... |
Group expressions using the OR character | >>> from collections import namedtuple >>> expr = namedtuple ( expr regex group_lengths run ) ( ( 1 ) [ 1 ] None ) >>> grouping = AlternatesGroup ( [ expr expr ] lambda f: None yeah ) >>> grouping. regex # doctest: + IGNORE_UNICODE ( ?: ( 1 )) | ( ?: ( 1 )) >>> grouping. group... | def AlternatesGroup(expressions, final_function, name=""):
""" Group expressions using the OR character ``|``
>>> from collections import namedtuple
>>> expr = namedtuple('expr', 'regex group_lengths run')('(1)', [1], None)
>>> grouping = AlternatesGroup([expr, expr], lambda f: None, 'yeah')
>>> gro... |
Group expressions together with inbetweens and with the output of a final_functions. | def Group(expressions, final_function, inbetweens, name=""):
""" Group expressions together with ``inbetweens`` and with the output of a ``final_functions``.
"""
lengths = []
functions = []
regex = ""
i = 0
for expression in expressions:
regex += inbetweens[i]
regex += "(?:" ... |
Parse string returning all outputs as parsed by functions | def findall(self, string):
""" Parse string, returning all outputs as parsed by functions
"""
output = []
for match in self.pattern.findall(string):
if hasattr(match, 'strip'):
match = [match]
self._list_add(output, self.run(match))
return ... |
Like findall but also returning matching start and end string locations | def scan(self, string):
""" Like findall, but also returning matching start and end string locations
"""
return list(self._scanner_to_matches(self.pattern.scanner(string), self.run)) |
Run group functions over matches | def run(self, matches):
""" Run group functions over matches
"""
def _run(matches):
group_starting_pos = 0
for current_pos, (group_length, group_function) in enumerate(zip(self.group_lengths, self.group_functions)):
start_pos = current_pos + group_starting... |
Specify logfile path | def set_logfile(path, instance):
"""Specify logfile path"""
global logfile
logfile = os.path.normpath(path) + '/hfos.' + instance + '.log' |
Checks if a logged event is to be muted for debugging purposes. | def is_muted(what):
"""
Checks if a logged event is to be muted for debugging purposes.
Also goes through the solo list - only items in there will be logged!
:param what:
:return:
"""
state = False
for item in solo:
if item not in what:
state = True
else:
... |
Logs all * what arguments. | def hfoslog(*what, **kwargs):
"""Logs all *what arguments.
:param *what: Loggable objects (i.e. they have a string representation)
:param lvl: Debug message level
:param exc: Switch to better handle exceptions, use if logging in an
except clause
:param emitter: Optional log source, ... |
Return a list of tagged objects for a schema | def get_tagged(self, event):
"""Return a list of tagged objects for a schema"""
self.log("Tagged objects request for", event.data, "from",
event.user, lvl=debug)
if event.data in self.tags:
tagged = self._get_tagged(event.data)
response = {
... |
Provisions the default system vessel | def provision_system_vessel(items, database_name, overwrite=False, clear=False, skip_user_check=False):
"""Provisions the default system vessel"""
from hfos.provisions.base import provisionList
from hfos.database import objectmodels
vessel = objectmodels['vessel'].find_one({'name': 'Default System Ves... |
Threadable function to retrieve map tiles from the internet: param url: URL of tile to get | def get_tile(url):
"""
Threadable function to retrieve map tiles from the internet
:param url: URL of tile to get
"""
log = ""
connection = None
try:
if six.PY3:
connection = urlopen(url=url, timeout=2) # NOQA
else:
connection = urlopen(url=url)
... |
Checks and caches a requested tile to disk then delivers it to client | def tilecache(self, event, *args, **kwargs):
"""Checks and caches a requested tile to disk, then delivers it to
client"""
request, response = event.args[:2]
self.log(request.path, lvl=verbose)
try:
filename, url = self._split_cache_url(request.path, 'tilecache')
... |
Convert from [ +/ - ] DDD°MMM SSS. SSSS or [ +/ - ] DDD°MMM. MMMM to [ +/ - ] DDD. DDDDD | def todegdec(origin):
"""
Convert from [+/-]DDD°MMM'SSS.SSSS" or [+/-]DDD°MMM.MMMM' to [+/-]DDD.DDDDD
"""
# if the input is already a float (or can be converted to float)
try:
return float(origin)
except ValueError:
pass
# DMS format
m = dms_re.search(origin)
if m:
... |
Convert [ +/ - ] DDD. DDDDD to a tuple ( degrees minutes ) | def tomindec(origin):
"""
Convert [+/-]DDD.DDDDD to a tuple (degrees, minutes)
"""
origin = float(origin)
degrees = int(origin)
minutes = (origin % 1) * 60
return degrees, minutes |
Convert [ +/ - ] DDD. DDDDD to [ +/ - ] DDD°MMM. MMMM | def tomindecstr(origin):
"""
Convert [+/-]DDD.DDDDD to [+/-]DDD°MMM.MMMM'
"""
degrees, minutes = tomindec(origin)
return u'%d°%f\'' % (degrees, minutes) |
Convert [ +/ - ] DDD. DDDDD to a tuple ( degrees minutes seconds ) | def todms(origin):
"""
Convert [+/-]DDD.DDDDD to a tuple (degrees, minutes, seconds)
"""
degrees, minutes = tomindec(origin)
seconds = (minutes % 1) * 60
return degrees, int(minutes), seconds |
Convert [ +/ - ] DDD. DDDDD to [ +/ - ] DDD°MMM DDD. DDDDD | def todmsstr(origin):
"""
Convert [+/-]DDD.DDDDD to [+/-]DDD°MMM'DDD.DDDDD"
"""
degrees, minutes, seconds = todms(origin)
return u'%d°%d\'%f"' % (degrees, minutes, seconds) |
Convert coordintes from TWD97 to WGS84 | def towgs84(E, N, pkm=False, presentation=None):
"""
Convert coordintes from TWD97 to WGS84
The east and north coordinates should be in meters and in float
pkm true for Penghu, Kinmen and Matsu area
You can specify one of the following presentations of the returned values:
dms - A tuple wit... |
Convert coordintes from WGS84 to TWD97 | def fromwgs84(lat, lng, pkm=False):
"""
Convert coordintes from WGS84 to TWD97
pkm true for Penghu, Kinmen and Matsu area
The latitude and longitude can be in the following formats:
[+/-]DDD°MMM'SSS.SSSS" (unicode)
[+/-]DDD°MMM.MMMM' (unicode)
[+/-]DDD.DDDDD (string, unicode or ... |
Makes sure that value is within a specific range. If not then the lower or upper bounds is returned | def clipValue(self, value, minValue, maxValue):
'''
Makes sure that value is within a specific range.
If not, then the lower or upper bounds is returned
'''
return min(max(value, minValue), maxValue) |
returns the ground resolution for based on latitude and zoom level. | def getGroundResolution(self, latitude, level):
'''
returns the ground resolution for based on latitude and zoom level.
'''
latitude = self.clipValue(latitude, self.min_lat, self.max_lat);
mapSize = self.getMapDimensionsByZoomLevel(level)
return math.cos(
lati... |
returns the map scale on the dpi of the screen | def getMapScale(self, latitude, level, dpi=96):
'''
returns the map scale on the dpi of the screen
'''
dpm = dpi / 0.0254 # convert to dots per meter
return self.getGroundResolution(latitude, level) * dpm |
returns the x and y values of the pixel corresponding to a latitude and longitude. | def convertLatLngToPixelXY(self, lat, lng, level):
'''
returns the x and y values of the pixel corresponding to a latitude
and longitude.
'''
mapSize = self.getMapDimensionsByZoomLevel(level)
lat = self.clipValue(lat, self.min_lat, self.max_lat)
lng = self.clipVa... |
converts a pixel x y to a latitude and longitude. | def convertPixelXYToLngLat(self, pixelX, pixelY, level):
'''
converts a pixel x, y to a latitude and longitude.
'''
mapSize = self.getMapDimensionsByZoomLevel(level)
x = (self.clipValue(pixelX, 0, mapSize - 1) / mapSize) - 0.5
y = 0.5 - (self.clipValue(pixelY, 0, mapSize ... |
Computes quadKey value based on tile x y and z values. | def tileXYZToQuadKey(self, x, y, z):
'''
Computes quadKey value based on tile x, y and z values.
'''
quadKey = ''
for i in range(z, 0, -1):
digit = 0
mask = 1 << (i - 1)
if (x & mask) != 0:
digit += 1
if (y & mask) !... |
Computes tile x y and z values based on quadKey. | def quadKeyToTileXYZ(self, quadKey):
'''
Computes tile x, y and z values based on quadKey.
'''
tileX = 0
tileY = 0
tileZ = len(quadKey)
for i in range(tileZ, 0, -1):
mask = 1 << (i - 1)
value = quadKey[tileZ - i]
if value == '... |
Returns the upper - left hand corner lat/ lng for a tile | def getTileOrigin(self, tileX, tileY, level):
'''
Returns the upper-left hand corner lat/lng for a tile
'''
pixelX, pixelY = self.convertTileXYToPixelXY(tileX, tileY)
lng, lat = self.convertPixelXYToLngLat(pixelX, pixelY, level)
return (lat, lng) |
Returns a list of tile urls by extent | def getTileUrlsByLatLngExtent(self, xmin, ymin, xmax, ymax, level):
'''
Returns a list of tile urls by extent
'''
# Upper-Left Tile
tileXMin, tileYMin = self.tileUtils.convertLngLatToTileXY(xmin, ymax,
level)
... |
returns new tile url based on template | def createTileUrl(self, x, y, z):
'''
returns new tile url based on template
'''
return self.tileTemplate.replace('{{x}}', str(x)).replace('{{y}}', str(
y)).replace('{{z}}', str(z)) |
Handles navigational reference frame updates. These are necessary to assign geo coordinates to alerts and other misc things. | def referenceframe(self, event):
"""Handles navigational reference frame updates.
These are necessary to assign geo coordinates to alerts and other
misc things.
:param event with incoming referenceframe message
"""
self.log("Got a reference frame update! ", event, lvl=e... |
Checks if an alert is ongoing and alerts the newly connected client if so. | def userlogin(self, event):
"""Checks if an alert is ongoing and alerts the newly connected
client, if so."""
client_uuid = event.clientuuid
self.log(event.user, pretty=True, lvl=verbose)
self.log('Adding client')
self.clients[event.clientuuid] = event.user
fo... |
AlertManager event handler for incoming events | def trigger(self, event):
"""AlertManager event handler for incoming events
:param event with incoming AlertManager message
"""
topic = event.data.get('topic', None)
if topic is None:
self.log('No alert topic to trigger', lvl=warn)
return
alert ... |
AlertManager event handler for incoming events | def cancel(self, event):
"""AlertManager event handler for incoming events
:param event with incoming AlertManager message
"""
topic = event.data.get('topic', None)
if topic is None:
self.log('No alert topic to cancel', lvl=warn)
return
self._can... |
Isomer Management Tool | def cli(ctx, instance, quiet, verbose, log_level, dbhost, dbname):
"""Isomer Management Tool
This tool supports various operations to manage isomer instances.
Most of the commands are grouped. To obtain more information about the
groups' available sub commands/groups, try
iso [group]
To disp... |
Primary entry point for all AstroCats catalogs. | def main():
"""Primary entry point for all AstroCats catalogs.
From this entry point, all internal catalogs can be accessed and their
public methods executed (for example: import scripts).
"""
from datetime import datetime
# Initialize Command-Line and User-Config Settings, Log
# --------... |
Setup a configuration file in the user s home directory. | def setup_user_config(log):
"""Setup a configuration file in the user's home directory.
Currently this method stores default values to a fixed configuration
filename. It should be modified to run an interactive prompt session
asking for parameters (or at least confirming the default ones).
Argume... |
Load settings from the user s confiuration file and add them to args. | def load_user_config(args, log):
"""Load settings from the user's confiuration file, and add them to `args`.
Settings are loaded from the configuration file in the user's home
directory. Those parameters are added (as attributes) to the `args`
object.
Arguments
---------
args : `argparse.... |
Load and parse command - line arguments. | def load_command_line_args(clargs=None):
"""Load and parse command-line arguments.
Arguments
---------
args : str or None
'Faked' commandline arguments passed to `argparse`.
Returns
-------
args : `argparse.Namespace` object
Namespace in which settings are stored - default ... |
Load a logging. Logger object. | def load_log(args):
"""Load a `logging.Logger` object.
Arguments
---------
args : `argparse.Namespace` object
Namespace containing required settings:
{`args.debug`, `args.verbose`, and `args.log_filename`}.
Returns
-------
log : `logging.Logger` object
"""
from ast... |
Function compares dictionaries by key - value recursively. | def compare_dicts(old_full, new_full, old_data, new_data, depth=0):
"""Function compares dictionaries by key-value recursively.
Old and new input data are both dictionaries
"""
depth = depth + 1
indent = " "*depth
# Print with an indentation matching the nested-dictionary depth
def my_pri... |
Clips a line to a rectangular area. | def cohensutherland(xmin, ymax, xmax, ymin, x1, y1, x2, y2):
"""Clips a line to a rectangular area.
This implements the Cohen-Sutherland line clipping algorithm. xmin,
ymax, xmax and ymin denote the clipping area, into which the line
defined by x1, y1 (start point) and x2, y2 (end point) will be
c... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.