code
stringlengths 52
7.75k
| docs
stringlengths 1
5.85k
|
|---|---|
def fw_hex_to_int(hex_str, words):
return struct.unpack('<{}H'.format(words), binascii.unhexlify(hex_str)) | Unpack hex string into integers.
Use little-endian and unsigned int format. Specify number of words to
unpack with argument words. |
def fw_int_to_hex(*args):
return binascii.hexlify(
struct.pack('<{}H'.format(len(args)), *args)).decode('utf-8') | Pack integers into hex string.
Use little-endian and unsigned int format. |
def compute_crc(data):
crc16 = crcmod.predefined.Crc('modbus')
crc16.update(data)
return int(crc16.hexdigest(), 16) | Compute CRC16 of data and return an int. |
def load_fw(path):
fname = os.path.realpath(path)
exists = os.path.isfile(fname)
if not exists or not os.access(fname, os.R_OK):
_LOGGER.error(
'Firmware path %s does not exist or is not readable',
path)
return None
try:
intel_hex = IntelHex()
with open(path, 'r') as file_handle:
intel_hex.fromfile(file_handle, format='hex')
return intel_hex.tobinstr()
except (IntelHexError, TypeError, ValueError) as exc:
_LOGGER.error(
'Firmware not valid, check the hex file at %s: %s', path, exc)
return None | Open firmware file and return a binary string. |
def prepare_fw(bin_string):
pads = len(bin_string) % 128 # 128 bytes per page for atmega328
for _ in range(128 - pads): # pad up to even 128 bytes
bin_string += b'\xff'
fware = {
'blocks': int(len(bin_string) / FIRMWARE_BLOCK_SIZE),
'crc': compute_crc(bin_string),
'data': bin_string,
}
return fware | Check that firmware is valid and return dict with binary data. |
def _get_fw(self, msg, updates, req_fw_type=None, req_fw_ver=None):
fw_type = None
fw_ver = None
if not isinstance(updates, tuple):
updates = (updates, )
for store in updates:
fw_id = store.pop(msg.node_id, None)
if fw_id is not None:
fw_type, fw_ver = fw_id
updates[-1][msg.node_id] = fw_id
break
if fw_type is None or fw_ver is None:
_LOGGER.debug(
'Node %s is not set for firmware update', msg.node_id)
return None, None, None
if req_fw_type is not None and req_fw_ver is not None:
fw_type, fw_ver = req_fw_type, req_fw_ver
fware = self.firmware.get((fw_type, fw_ver))
if fware is None:
_LOGGER.debug(
'No firmware of type %s and version %s found',
fw_type, fw_ver)
return None, None, None
return fw_type, fw_ver, fware | Get firmware type, version and a dict holding binary data. |
def respond_fw(self, msg):
req_fw_type, req_fw_ver, req_blk = fw_hex_to_int(msg.payload, 3)
_LOGGER.debug(
'Received firmware request with firmware type %s, '
'firmware version %s, block index %s',
req_fw_type, req_fw_ver, req_blk)
fw_type, fw_ver, fware = self._get_fw(
msg, (self.unstarted, self.started), req_fw_type, req_fw_ver)
if fware is None:
return None
blk_data = fware['data'][
req_blk * FIRMWARE_BLOCK_SIZE:
req_blk * FIRMWARE_BLOCK_SIZE + FIRMWARE_BLOCK_SIZE]
msg = msg.copy(sub_type=self._const.Stream.ST_FIRMWARE_RESPONSE)
msg.payload = fw_int_to_hex(fw_type, fw_ver, req_blk)
# format blk_data into payload format
msg.payload = msg.payload + binascii.hexlify(blk_data).decode('utf-8')
return msg | Respond to a firmware request. |
def respond_fw_config(self, msg):
(req_fw_type,
req_fw_ver,
req_blocks,
req_crc,
bloader_ver) = fw_hex_to_int(msg.payload, 5)
_LOGGER.debug(
'Received firmware config request with firmware type %s, '
'firmware version %s, %s blocks, CRC %s, bootloader %s',
req_fw_type, req_fw_ver, req_blocks, req_crc, bloader_ver)
fw_type, fw_ver, fware = self._get_fw(
msg, (self.requested, self.unstarted))
if fware is None:
return None
if fw_type != req_fw_type:
_LOGGER.warning(
'Firmware type %s of update is not identical to existing '
'firmware type %s for node %s',
fw_type, req_fw_type, msg.node_id)
_LOGGER.info(
'Updating node %s to firmware type %s version %s from type %s '
'version %s', msg.node_id, fw_type, fw_ver, req_fw_type,
req_fw_ver)
msg = msg.copy(sub_type=self._const.Stream.ST_FIRMWARE_CONFIG_RESPONSE)
msg.payload = fw_int_to_hex(
fw_type, fw_ver, fware['blocks'], fware['crc'])
return msg | Respond to a firmware config request. |
def make_update(self, nids, fw_type, fw_ver, fw_bin=None):
try:
fw_type, fw_ver = int(fw_type), int(fw_ver)
except ValueError:
_LOGGER.error(
'Firmware type %s or version %s not valid, '
'please enter integers', fw_type, fw_ver)
return
if fw_bin is not None:
fware = prepare_fw(fw_bin)
self.firmware[fw_type, fw_ver] = fware
if (fw_type, fw_ver) not in self.firmware:
_LOGGER.error(
'No firmware of type %s and version %s found, '
'please enter path to firmware in call', fw_type, fw_ver)
return
if not isinstance(nids, list):
nids = [nids]
for node_id in nids:
if node_id not in self._sensors:
continue
for store in self.unstarted, self.started:
store.pop(node_id, None)
self.requested[node_id] = fw_type, fw_ver
self._sensors[node_id].reboot = True | Start firmware update process for one or more node_id. |
def handle_smartsleep(msg):
while msg.gateway.sensors[msg.node_id].queue:
msg.gateway.add_job(
str, msg.gateway.sensors[msg.node_id].queue.popleft())
for child in msg.gateway.sensors[msg.node_id].children.values():
new_child = msg.gateway.sensors[msg.node_id].new_state.get(
child.id, ChildSensor(child.id, child.type, child.description))
msg.gateway.sensors[msg.node_id].new_state[child.id] = new_child
for value_type, value in child.values.items():
new_value = new_child.values.get(value_type)
if new_value is not None and new_value != value:
msg.gateway.add_job(
msg.gateway.sensors[msg.node_id].set_child_value,
child.id, value_type, new_value) | Process a message before going back to smartsleep. |
def handle_presentation(msg):
if msg.child_id == SYSTEM_CHILD_ID:
# this is a presentation of the sensor platform
sensorid = msg.gateway.add_sensor(msg.node_id)
if sensorid is None:
return None
msg.gateway.sensors[msg.node_id].type = msg.sub_type
msg.gateway.sensors[msg.node_id].protocol_version = msg.payload
# Set reboot to False after a node reboot.
msg.gateway.sensors[msg.node_id].reboot = False
msg.gateway.alert(msg)
return msg
# this is a presentation of a child sensor
if not msg.gateway.is_sensor(msg.node_id):
_LOGGER.error('Node %s is unknown, will not add child %s',
msg.node_id, msg.child_id)
return None
child_id = msg.gateway.sensors[msg.node_id].add_child_sensor(
msg.child_id, msg.sub_type, msg.payload)
if child_id is None:
return None
msg.gateway.alert(msg)
return msg | Process a presentation message. |
def handle_set(msg):
if not msg.gateway.is_sensor(msg.node_id, msg.child_id):
return None
msg.gateway.sensors[msg.node_id].set_child_value(
msg.child_id, msg.sub_type, msg.payload)
if msg.gateway.sensors[msg.node_id].new_state:
msg.gateway.sensors[msg.node_id].set_child_value(
msg.child_id, msg.sub_type, msg.payload,
children=msg.gateway.sensors[msg.node_id].new_state)
msg.gateway.alert(msg)
# Check if reboot is true
if msg.gateway.sensors[msg.node_id].reboot:
return msg.copy(
child_id=SYSTEM_CHILD_ID,
type=msg.gateway.const.MessageType.internal, ack=0,
sub_type=msg.gateway.const.Internal.I_REBOOT, payload='')
return None | Process a set message. |
def handle_req(msg):
if not msg.gateway.is_sensor(msg.node_id, msg.child_id):
return None
value = msg.gateway.sensors[msg.node_id].children[
msg.child_id].values.get(msg.sub_type)
if value is not None:
return msg.copy(
type=msg.gateway.const.MessageType.set, payload=value)
return None | Process a req message.
This will return the value if it exists. If no value exists,
nothing is returned. |
def handle_internal(msg):
internal = msg.gateway.const.Internal(msg.sub_type)
handler = internal.get_handler(msg.gateway.handlers)
if handler is None:
return None
return handler(msg) | Process an internal message. |
def handle_stream(msg):
if not msg.gateway.is_sensor(msg.node_id):
return None
stream = msg.gateway.const.Stream(msg.sub_type)
handler = stream.get_handler(msg.gateway.handlers)
if handler is None:
return None
return handler(msg) | Process a stream type message. |
def handle_id_request(msg):
node_id = msg.gateway.add_sensor()
return msg.copy(
ack=0, sub_type=msg.gateway.const.Internal['I_ID_RESPONSE'],
payload=node_id) if node_id is not None else None | Process an internal id request message. |
def handle_time(msg):
return msg.copy(ack=0, payload=calendar.timegm(time.localtime())) | Process an internal time request message. |
def handle_battery_level(msg):
if not msg.gateway.is_sensor(msg.node_id):
return None
msg.gateway.sensors[msg.node_id].battery_level = msg.payload
msg.gateway.alert(msg)
return None | Process an internal battery level message. |
def handle_sketch_name(msg):
if not msg.gateway.is_sensor(msg.node_id):
return None
msg.gateway.sensors[msg.node_id].sketch_name = msg.payload
msg.gateway.alert(msg)
return None | Process an internal sketch name message. |
def handle_sketch_version(msg):
if not msg.gateway.is_sensor(msg.node_id):
return None
msg.gateway.sensors[msg.node_id].sketch_version = msg.payload
msg.gateway.alert(msg)
return None | Process an internal sketch version message. |
def handle_log_message(msg): # pylint: disable=useless-return
msg.gateway.can_log = True
_LOGGER.debug(
'n:%s c:%s t:%s s:%s p:%s', msg.node_id, msg.child_id, msg.type,
msg.sub_type, msg.payload)
return None | Process an internal log message. |
def handle_gateway_ready(msg): # pylint: disable=useless-return
_LOGGER.info(
'n:%s c:%s t:%s s:%s p:%s', msg.node_id, msg.child_id, msg.type,
msg.sub_type, msg.payload)
msg.gateway.alert(msg)
return None | Process an internal gateway ready message. |
def handle_gateway_ready_20(msg):
_LOGGER.info(
'n:%s c:%s t:%s s:%s p:%s', msg.node_id, msg.child_id, msg.type,
msg.sub_type, msg.payload)
msg.gateway.alert(msg)
return msg.copy(
node_id=255, ack=0,
sub_type=msg.gateway.const.Internal.I_DISCOVER, payload='') | Process an internal gateway ready message. |
def handle_heartbeat_response(msg):
if not msg.gateway.is_sensor(msg.node_id):
return None
handle_smartsleep(msg)
msg.gateway.sensors[msg.node_id].heartbeat = msg.payload
msg.gateway.alert(msg)
return None | Process an internal heartbeat response message. |
def handle_heartbeat_response_22(msg):
if not msg.gateway.is_sensor(msg.node_id):
return None
msg.gateway.sensors[msg.node_id].heartbeat = msg.payload
msg.gateway.alert(msg)
return None | Process an internal heartbeat response message. |
def publish(self, topic, payload, qos, retain):
self._mqttc.publish(topic, payload, qos, retain) | Publish an MQTT message. |
def subscribe(self, topic, callback, qos):
if topic in self.topics:
return
def _message_callback(mqttc, userdata, msg):
"""Callback added to callback list for received message."""
callback(msg.topic, msg.payload.decode('utf-8'), msg.qos)
self._mqttc.subscribe(topic, qos)
self._mqttc.message_callback_add(topic, _message_callback)
self.topics[topic] = callback | Subscribe to an MQTT topic. |
def get_gateway_id(self):
info = next(serial.tools.list_ports.grep(self.port), None)
return info.serial_number if info is not None else None | Return a unique id for the gateway. |
def _connect(self):
while self.protocol:
_LOGGER.info('Trying to connect to %s', self.port)
try:
ser = serial.serial_for_url(
self.port, self.baud, timeout=self.timeout)
except serial.SerialException:
_LOGGER.error('Unable to connect to %s', self.port)
_LOGGER.info(
'Waiting %s secs before trying to connect again',
self.reconnect_timeout)
time.sleep(self.reconnect_timeout)
else:
transport = serial.threaded.ReaderThread(
ser, lambda: self.protocol)
transport.daemon = False
poll_thread = threading.Thread(target=self._poll_queue)
self._stop_event.clear()
poll_thread.start()
transport.start()
transport.connect()
return | Connect to the serial port. This should be run in a new thread. |
def _connect(self):
try:
while True:
_LOGGER.info('Trying to connect to %s', self.port)
try:
yield from serial_asyncio.create_serial_connection(
self.loop, lambda: self.protocol, self.port, self.baud)
return
except serial.SerialException:
_LOGGER.error('Unable to connect to %s', self.port)
_LOGGER.info(
'Waiting %s secs before trying to connect again',
self.reconnect_timeout)
yield from asyncio.sleep(
self.reconnect_timeout, loop=self.loop)
except asyncio.CancelledError:
_LOGGER.debug('Connect attempt to %s cancelled', self.port) | Connect to the serial port. |
def is_version(value):
try:
value = str(value)
if not parse_ver('1.4') <= parse_ver(value):
raise ValueError()
return value
except (AttributeError, TypeError, ValueError):
raise vol.Invalid(
'{} is not a valid version specifier'.format(value)) | Validate that value is a valid version string. |
def is_battery_level(value):
try:
value = percent_int(value)
return value
except vol.Invalid:
_LOGGER.warning(
'%s is not a valid battery level, falling back to battery level 0',
value)
return 0 | Validate that value is a valid battery level integer. |
def is_heartbeat(value):
try:
value = vol.Coerce(int)(value)
return value
except vol.Invalid:
_LOGGER.warning(
'%s is not a valid heartbeat value, falling back to heartbeat 0',
value)
return 0 | Validate that value is a valid heartbeat integer. |
def mksalt(method=None, rounds=None):
if method is None:
method = methods[0]
salt = ['${0}$'.format(method.ident) if method.ident else '']
if rounds:
salt.append('rounds={0:d}$'.format(rounds))
salt.append(''.join(_sr.choice(_BASE64_CHARACTERS) for char in range(method.salt_chars)))
return ''.join(salt) | Generate a salt for the specified method.
If not specified, the strongest available method will be used. |
def crypt(word, salt=None, rounds=_ROUNDS_DEFAULT):
if salt is None or isinstance(salt, _Method):
salt = mksalt(salt, rounds)
algo, rounds, salt = extract_components_from_salt(salt)
if algo == 5:
hashfunc = hashlib.sha256
elif algo == 6:
hashfunc = hashlib.sha512
else:
raise ValueError('Unsupported algorithm, must be either 5 (sha256) or 6 (sha512)')
return sha2_crypt(word, salt, hashfunc, rounds) | Return a string representing the one-way hash of a password, with a salt
prepended.
If ``salt`` is not specified or is ``None``, the strongest
available method will be selected and a salt generated. Otherwise,
``salt`` may be one of the ``crypt.METHOD_*`` values, or a string as
returned by ``crypt.mksalt()``. |
def double_prompt_for_plaintext_password():
password = 1
password_repeat = 2
while password != password_repeat:
password = getpass.getpass('Enter password: ')
password_repeat = getpass.getpass('Repeat password: ')
if password != password_repeat:
sys.stderr.write('Passwords do not match, try again.\n')
return password | Get the desired password from the user through a double prompt. |
def logic(self, data):
try:
msg = Message(data, self)
msg.validate(self.protocol_version)
except (ValueError, vol.Invalid) as exc:
_LOGGER.warning('Not a valid message: %s', exc)
return None
message_type = self.const.MessageType(msg.type)
handler = message_type.get_handler(self.handlers)
ret = handler(msg)
ret = self._route_message(ret)
ret = ret.encode() if ret else None
return ret | Parse the data and respond to it appropriately.
Response is returned to the caller and has to be sent
data as a mysensors command string. |
def alert(self, msg):
if self.event_callback is not None:
try:
self.event_callback(msg)
except Exception as exception: # pylint: disable=broad-except
_LOGGER.exception(exception)
if self.persistence:
self.persistence.need_save = True | Tell anyone who wants to know that a sensor was updated. |
def _get_next_id(self):
if self.sensors:
next_id = max(self.sensors.keys()) + 1
else:
next_id = 1
if next_id <= self.const.MAX_NODE_ID:
return next_id
return None | Return the next available sensor id. |
def add_sensor(self, sensorid=None):
if sensorid is None:
sensorid = self._get_next_id()
if sensorid is not None and sensorid not in self.sensors:
self.sensors[sensorid] = Sensor(sensorid)
return sensorid if sensorid in self.sensors else None | Add a sensor to the gateway. |
def is_sensor(self, sensorid, child_id=None):
ret = sensorid in self.sensors
if not ret:
_LOGGER.warning('Node %s is unknown', sensorid)
if ret and child_id is not None:
ret = child_id in self.sensors[sensorid].children
if not ret:
_LOGGER.warning('Child %s is unknown', child_id)
if not ret and parse_ver(self.protocol_version) >= parse_ver('2.0'):
_LOGGER.info('Requesting new presentation for node %s',
sensorid)
msg = Message(gateway=self).modify(
node_id=sensorid, child_id=SYSTEM_CHILD_ID,
type=self.const.MessageType.internal,
sub_type=self.const.Internal.I_PRESENTATION)
if self._route_message(msg):
self.add_job(msg.encode)
return ret | Return True if a sensor and its child exist. |
def run_job(self, job=None):
if job is None:
if not self.queue:
return None
job = self.queue.popleft()
start = timer()
func, args = job
reply = func(*args)
end = timer()
if end - start > 0.1:
_LOGGER.debug(
'Handle queue with call %s(%s) took %.3f seconds',
func, args, end - start)
return reply | Run a job, either passed in or from the queue.
A job is a tuple of function and optional args. Keyword arguments
can be passed via use of functools.partial. The job should return a
string that should be sent by the gateway protocol. The function will
be called with the arguments and the result will be returned. |
def set_child_value(
self, sensor_id, child_id, value_type, value, **kwargs):
if not self.is_sensor(sensor_id, child_id):
return
if self.sensors[sensor_id].new_state:
self.sensors[sensor_id].set_child_value(
child_id, value_type, value,
children=self.sensors[sensor_id].new_state)
else:
self.add_job(partial(
self.sensors[sensor_id].set_child_value, child_id, value_type,
value, **kwargs)) | Add a command to set a sensor value, to the queue.
A queued command will be sent to the sensor when the gateway
thread has sent all previously queued commands.
If the sensor attribute new_state returns True, the command will be
buffered in a queue on the sensor, and only the internal sensor state
will be updated. When a smartsleep message is received, the internal
state will be pushed to the sensor, via _handle_smartsleep method. |
def start(self):
connect_thread = threading.Thread(target=self._connect)
connect_thread.start() | Start the connection to a transport. |
def _poll_queue(self):
while not self._stop_event.is_set():
reply = self.run_job()
self.send(reply)
if self.queue:
continue
time.sleep(0.02) | Poll the queue for work. |
def _create_scheduler(self, save_sensors):
def schedule_save():
"""Save sensors and schedule a new save."""
save_sensors()
scheduler = threading.Timer(10.0, schedule_save)
scheduler.start()
self._cancel_save = scheduler.cancel
return schedule_save | Return function to schedule saving sensors. |
def start_persistence(self):
if not self.persistence:
return
self.persistence.safe_load_sensors()
self.persistence.schedule_save_sensors() | Load persistence file and schedule saving of persistence file. |
def stop(self):
self._stop_event.set()
if not self.persistence:
return
if self._cancel_save is not None:
self._cancel_save()
self._cancel_save = None
self.persistence.save_sensors() | Stop the background thread. |
def update_fw(self, nids, fw_type, fw_ver, fw_path=None):
fw_bin = None
if fw_path:
fw_bin = load_fw(fw_path)
if not fw_bin:
return
self.ota.make_update(nids, fw_type, fw_ver, fw_bin) | Update firwmare of all node_ids in nids. |
def _disconnect(self):
if not self.protocol or not self.protocol.transport:
self.protocol = None # Make sure protocol is None
return
_LOGGER.info('Disconnecting from gateway')
self.protocol.transport.close()
self.protocol = None | Disconnect from the transport. |
def send(self, message):
if not message or not self.protocol or not self.protocol.transport:
return
if not self.can_log:
_LOGGER.debug('Sending %s', message.strip())
try:
self.protocol.transport.write(message.encode())
except OSError as exc:
_LOGGER.error(
'Failed writing to transport %s: %s',
self.protocol.transport, exc)
self.protocol.transport.close()
self.protocol.conn_lost_callback() | Write a message to the gateway. |
def stop(self):
_LOGGER.info('Stopping gateway')
self._disconnect()
if self.connect_task and not self.connect_task.cancelled():
self.connect_task.cancel()
self.connect_task = None
if not self.persistence:
return
if self._cancel_save is not None:
self._cancel_save()
self._cancel_save = None
yield from self.loop.run_in_executor(
None, self.persistence.save_sensors) | Stop the gateway. |
def add_job(self, func, *args):
job = func, args
reply = self.run_job(job)
self.send(reply) | Add a job that should return a reply to be sent.
A job is a tuple of function and optional args. Keyword arguments
can be passed via use of functools.partial. The job should return a
string that should be sent by the gateway protocol.
The async version of this method will send the reply directly. |
def _create_scheduler(self, save_sensors):
@asyncio.coroutine
def schedule_save():
"""Save sensors and schedule a new save."""
yield from self.loop.run_in_executor(None, save_sensors)
callback = partial(self.loop.create_task, schedule_save())
task = self.loop.call_later(10.0, callback)
self._cancel_save = task.cancel
return schedule_save | Return function to schedule saving sensors. |
def start_persistence(self):
if not self.persistence:
return
yield from self.loop.run_in_executor(
None, self.persistence.safe_load_sensors)
yield from self.persistence.schedule_save_sensors() | Load persistence file and schedule saving of persistence file. |
def connection_made(self, transport):
super().connection_made(transport)
if hasattr(self.transport, 'serial'):
_LOGGER.info('Connected to %s', self.transport.serial)
else:
_LOGGER.info('Connected to %s', self.transport) | Handle created connection. |
def handle_line(self, line):
if not self.gateway.can_log:
_LOGGER.debug('Receiving %s', line)
self.gateway.add_job(self.gateway.logic, line) | Handle incoming string data one line at a time. |
def connection_lost(self, exc):
_LOGGER.debug('Connection lost with %s', self.transport.serial)
if exc:
_LOGGER.error(exc)
self.transport.serial.close()
self.conn_lost_callback()
self.transport = None | Handle lost connection. |
def add_child_sensor(self, child_id, child_type, description=''):
if child_id in self.children:
_LOGGER.warning(
'child_id %s already exists in children of node %s, '
'cannot add child', child_id, self.sensor_id)
return None
self.children[child_id] = ChildSensor(
child_id, child_type, description)
return child_id | Create and add a child sensor. |
def set_child_value(self, child_id, value_type, value, **kwargs):
children = kwargs.get('children', self.children)
if not isinstance(children, dict) or child_id not in children:
return None
msg_type = kwargs.get('msg_type', 1)
ack = kwargs.get('ack', 0)
msg = Message().modify(
node_id=self.sensor_id, child_id=child_id, type=msg_type, ack=ack,
sub_type=value_type, payload=value)
msg_string = msg.encode()
if msg_string is None:
_LOGGER.error(
'Not a valid message: node %s, child %s, type %s, ack %s, '
'sub_type %s, payload %s',
self.sensor_id, child_id, msg_type, ack, value_type, value)
return None
try:
msg = Message(msg_string)
msg.validate(self.protocol_version)
except (ValueError, AttributeError, vol.Invalid) as exc:
_LOGGER.error('Not a valid message: %s', exc)
return None
child = children[msg.child_id]
child.values[msg.sub_type] = msg.payload
return msg_string | Set a child sensor's value. |
def get_schema(self, protocol_version):
const = get_const(protocol_version)
custom_schema = vol.Schema({
typ.value: const.VALID_SETREQ[typ]
for typ in const.VALID_TYPES[const.Presentation.S_CUSTOM]})
return custom_schema.extend({
typ.value: const.VALID_SETREQ[typ]
for typ in const.VALID_TYPES[self.type]}) | Return the child schema for the correct const version. |
def validate(self, protocol_version, values=None):
if values is None:
values = self.values
return self.get_schema(protocol_version)(values) | Validate child value types and values against protocol_version. |
def _get_shipped_from(row):
try:
spans = row.find('div', {'id': 'coltextR2'}).find_all('span')
if len(spans) < 2:
return None
return spans[1].string
except AttributeError:
return None | Get where package was shipped from. |
def _get_status_timestamp(row):
try:
divs = row.find('div', {'id': 'coltextR3'}).find_all('div')
if len(divs) < 2:
return None
timestamp_string = divs[1].string
except AttributeError:
return None
try:
return parse(timestamp_string)
except ValueError:
return None | Get latest package timestamp. |
def _get_delivery_date(row):
try:
month = row.find('div', {'class': 'date-small'}).string
day = row.find('div', {'class': 'date-num-large'}).string
except AttributeError:
return None
try:
return parse('{} {}'.format(month, day)).date()
except ValueError:
return None | Get delivery date (estimated or actual). |
def _get_driver(driver_type):
if driver_type == 'phantomjs':
return webdriver.PhantomJS(service_log_path=os.path.devnull)
if driver_type == 'firefox':
return webdriver.Firefox(firefox_options=FIREFOXOPTIONS)
elif driver_type == 'chrome':
chrome_options = webdriver.ChromeOptions()
for arg in CHROME_WEBDRIVER_ARGS:
chrome_options.add_argument(arg)
return webdriver.Chrome(chrome_options=chrome_options)
else:
raise USPSError('{} not supported'.format(driver_type)) | Get webdriver. |
def _login(session):
_LOGGER.debug("attempting login")
session.cookies.clear()
try:
session.remove_expired_responses()
except AttributeError:
pass
try:
driver = _get_driver(session.auth.driver)
except WebDriverException as exception:
raise USPSError(str(exception))
driver.get(LOGIN_URL)
username = driver.find_element_by_name('username')
username.send_keys(session.auth.username)
password = driver.find_element_by_name('password')
password.send_keys(session.auth.password)
driver.find_element_by_id('btn-submit').click()
try:
WebDriverWait(driver, LOGIN_TIMEOUT).until(EC.title_is(WELCOME_TITLE))
except TimeoutException:
raise USPSError('login failed')
for cookie in driver.get_cookies():
session.cookies.set(name=cookie['name'], value=cookie['value'])
_save_cookies(session.cookies, session.auth.cookie_path) | Login.
Use Selenium webdriver to login. USPS authenticates users
in part by a key generated by complex, obfuscated client-side
Javascript, which can't (easily) be replicated in Python.
Invokes the webdriver once to perform login, then uses the
resulting session cookies with a standard Python `requests`
session. |
def authenticated(function):
def wrapped(*args):
"""Wrap function."""
try:
return function(*args)
except USPSError:
_LOGGER.info("attempted to access page before login")
_login(args[0])
return function(*args)
return wrapped | Re-authenticate if session expired. |
def get_profile(session):
response = session.get(PROFILE_URL, allow_redirects=False)
if response.status_code == 302:
raise USPSError('expired session')
parsed = BeautifulSoup(response.text, HTML_PARSER)
profile = parsed.find('div', {'class': 'atg_store_myProfileInfo'})
data = {}
for row in profile.find_all('tr'):
cells = row.find_all('td')
if len(cells) == 2:
key = ' '.join(cells[0].find_all(text=True)).strip().lower().replace(' ', '_')
value = ' '.join(cells[1].find_all(text=True)).strip()
data[key] = value
return data | Get profile data. |
def get_packages(session):
_LOGGER.info("attempting to get package data")
response = _get_dashboard(session)
parsed = BeautifulSoup(response.text, HTML_PARSER)
packages = []
for row in parsed.find_all('div', {'class': 'pack_row'}):
packages.append({
'tracking_number': _get_tracking_number(row),
'primary_status': _get_primary_status(row),
'secondary_status': _get_secondary_status(row),
'status_timestamp': _get_status_timestamp(row),
'shipped_from': _get_shipped_from(row),
'delivery_date': _get_delivery_date(row)
})
return packages | Get package data. |
def get_mail(session, date=None):
_LOGGER.info("attempting to get mail data")
if not date:
date = datetime.datetime.now().date()
response = _get_dashboard(session, date)
parsed = BeautifulSoup(response.text, HTML_PARSER)
mail = []
for row in parsed.find_all('div', {'class': 'mailpiece'}):
image = _get_mailpiece_image(row)
if not image:
continue
mail.append({
'id': _get_mailpiece_id(image),
'image': _get_mailpiece_url(image),
'date': date
})
return mail | Get mail data. |
def get_session(username, password, cookie_path=COOKIE_PATH, cache=True,
cache_expiry=300, cache_path=CACHE_PATH, driver='phantomjs'):
class USPSAuth(AuthBase): # pylint: disable=too-few-public-methods
"""USPS authorization storage."""
def __init__(self, username, password, cookie_path, driver):
"""Init."""
self.username = username
self.password = password
self.cookie_path = cookie_path
self.driver = driver
def __call__(self, r):
"""Call is no-op."""
return r
session = requests.Session()
if cache:
session = requests_cache.core.CachedSession(cache_name=cache_path,
expire_after=cache_expiry)
session.auth = USPSAuth(username, password, cookie_path, driver)
session.headers.update({'User-Agent': USER_AGENT})
if os.path.exists(cookie_path):
_LOGGER.debug("cookie found at: %s", cookie_path)
session.cookies = _load_cookies(cookie_path)
else:
_login(session)
return session | Get session, existing or new. |
def rc4(data, key):
S, j, out = list(range(256)), 0, []
for i in range(256):
j = (j + S[i] + ord(key[i % len(key)])) % 256
S[i], S[j] = S[j], S[i]
i = j = 0
for ch in data:
i = (i + 1) % 256
j = (j + S[i]) % 256
S[i], S[j] = S[j], S[i]
out.append(chr(ord(ch) ^ S[(S[i] + S[j]) % 256]))
return "".join(out) | RC4 encryption and decryption method. |
def verify_email_for_object(self, email, content_object, email_field_name='email'):
confirmation_key = generate_random_token()
try:
confirmation = EmailConfirmation()
confirmation.content_object = content_object
confirmation.email_field_name = email_field_name
confirmation.email = email
confirmation.confirmation_key = confirmation_key
confirmation.save()
except IntegrityError:
confirmation = EmailConfirmation.objects.get_for_object(content_object, email_field_name)
confirmation.email = email
confirmation.confirmation_key = confirmation_key
confirmation.save(update_fields=['email', 'confirmation_key'])
confirmation.send()
return confirmation | Create an email confirmation for `content_object` and send a confirmation mail.
The email will be directly saved to `content_object.email_field_name` when `is_primary` and `skip_verify` both are true. |
def clean(self):
EmailConfirmation.objects.filter(content_type=self.content_type, object_id=self.object_id, email_field_name=self.email_field_name).delete() | delete all confirmations for the same content_object and the same field |
def render_paginate(request, template, objects, per_page, extra_context={}):
paginator = Paginator(objects, per_page)
page = request.GET.get('page', 1)
get_params = '&'.join(['%s=%s' % (k, request.GET[k])
for k in request.GET if k != 'page'])
try:
page_number = int(page)
except ValueError:
if page == 'last':
page_number = paginator.num_pages
else:
raise Http404
try:
page_obj = paginator.page(page_number)
except InvalidPage:
raise Http404
context = {
'object_list': page_obj.object_list,
'paginator': paginator,
'page_obj': page_obj,
'is_paginated': page_obj.has_other_pages(),
'get_params': get_params
}
context.update(extra_context)
return render(request, template, context) | Paginated list of objects. |
def values(self):
report = {}
for k, k_changes in self._changes.items():
if len(k_changes) == 1:
report[k] = k_changes[0].new_value
elif k_changes[0].old_value != k_changes[-1].new_value:
report[k] = k_changes[-1].new_value
return report | Returns a mapping of items to their new values. The mapping includes only items whose value or raw string value
has changed in the context. |
def changes(self):
report = {}
for k, k_changes in self._changes.items():
if len(k_changes) == 1:
report[k] = k_changes[0]
else:
first = k_changes[0]
last = k_changes[-1]
if first.old_value != last.new_value or first.old_raw_str_value != last.new_raw_str_value:
report[k] = _Change(
first.old_value,
last.new_value,
first.old_raw_str_value,
last.new_raw_str_value,
)
return report | Returns a mapping of items to their effective change objects which include the old values
and the new. The mapping includes only items whose value or raw string value has changed in the context. |
def load(self, source, as_defaults=False):
if isinstance(source, six.string_types):
source = os.path.expanduser(source)
with open(source, encoding='utf-8') as f:
self._rw.load_config_from_file(self._config, f, as_defaults=as_defaults)
elif isinstance(source, (list, tuple)):
for s in source:
with open(s, encoding='utf-8') as f:
self._rw.load_config_from_file(self._config, f, as_defaults=as_defaults)
else:
self._rw.load_config_from_file(self._config, source, as_defaults=as_defaults) | Load configuration values from the specified source.
Args:
source:
as_defaults (bool): if ``True``, contents of ``source`` will be treated as schema of configuration items. |
def loads(self, config_str, as_defaults=False):
self._rw.load_config_from_string(self._config, config_str, as_defaults=as_defaults) | Load configuration values from the specified source string.
Args:
config_str:
as_defaults (bool): if ``True``, contents of ``source`` will be treated as schema of configuration items. |
def dump(self, destination, with_defaults=False):
if isinstance(destination, six.string_types):
with open(destination, 'w', encoding='utf-8') as f:
self._rw.dump_config_to_file(self._config, f, with_defaults=with_defaults)
else:
self._rw.dump_config_to_file(self._config, destination, with_defaults=with_defaults) | Write configuration values to the specified destination.
Args:
destination:
with_defaults (bool): if ``True``, values of items with no custom values will be included in the output
if they have a default value set. |
def dumps(self, with_defaults=False):
return self._rw.dump_config_to_string(self._config, with_defaults=with_defaults) | Generate a string representing all the configuration values.
Args:
with_defaults (bool): if ``True``, values of items with no custom values will be included in the output
if they have a default value set. |
def _default_key_setter(self, name, subject):
if is_config_item(subject):
self.add_item(name, subject)
elif is_config_section(subject):
self.add_section(name, subject)
else:
raise TypeError(
'Section items can only be replaced with items, '
'got {type}. To set item value use ...{name}.value = <new_value>'.format(
type=type(subject),
name=name,
)
) | This method is used only when there is a custom key_setter set.
Do not override this method. |
def _set_key(self, key, value):
if is_config_section(value):
self.add_section(key, value)
return
if key not in self._tree or self.settings.key_setter is None:
if is_config_item(value):
self.add_item(key, value)
return
raise TypeError(
'Section sections/items can only be replaced with sections/items, '
'got {type}. To set value use ..[{name}].value = <new_value>'.format(
type=type(value),
name=key,
)
)
if self.settings.key_setter is None:
self._default_key_setter(key, value)
else:
self.settings.key_setter(subject=self._tree[key], value=value, default_key_setter=self._default_key_setter) | This method must NOT be called from outside the Section class.
Do not override this method. |
def _get_by_key(self, key, handle_not_found=True):
resolution = self._get_item_or_section(key, handle_not_found=handle_not_found)
if self.settings.key_getter:
return self.settings.key_getter(parent=self, subject=resolution)
else:
return resolution | This method must NOT be called from outside the Section class.
Do not override this method. |
def _get_item_or_section(self, key, handle_not_found=True):
if isinstance(key, six.string_types):
if self.settings.str_path_separator in key:
return self._get_item_or_section(key.split(self.settings.str_path_separator))
if key.endswith('_') and keyword.iskeyword(key[:-1]):
key = key[:-1]
if key in self._tree:
resolution = self._tree[key]
else:
if handle_not_found:
result = self.dispatch_event(self.hooks.not_found, name=key, section=self)
if result is not None:
resolution = result
else:
raise NotFound(key, section=self)
else:
raise NotFound(key, section=self)
elif isinstance(key, (tuple, list)) and len(key) > 0:
if len(key) == 1:
resolution = self._get_item_or_section(key[0], handle_not_found=handle_not_found)
else:
resolution = self._get_item_or_section(
key[0], handle_not_found=handle_not_found
)._get_item_or_section(key[1:], handle_not_found=handle_not_found)
else:
raise TypeError('Expected either a string or a tuple as key, got {!r}'.format(key))
return resolution | This method must NOT be called from outside the Section class.
Do not override this method.
If handle_not_found is set to False, hooks won't be called.
This is needed when checking key existence -- the whole
purpose of key existence checking is to avoid errors (and error handling). |
def get_item(self, *key):
item = self._get_item_or_section(key)
if not item.is_item:
raise RuntimeError('{} is a section, not an item'.format(key))
return item | The recommended way of retrieving an item by key when extending configmanager's behaviour.
Attribute and dictionary key access is configurable and may not always return items
(see PlainConfig for example), whereas this method will always return the corresponding
Item as long as NOT_FOUND hook callbacks don't break this convention.
Args:
*key
Returns:
item (:class:`.Item`): |
def get_section(self, *key):
section = self._get_item_or_section(key)
if not section.is_section:
raise RuntimeError('{} is an item, not a section'.format(key))
return section | The recommended way of retrieving a section by key when extending configmanager's behaviour. |
def add_item(self, alias, item):
if not isinstance(alias, six.string_types):
raise TypeError('Item name must be a string, got a {!r}'.format(type(alias)))
item = copy.deepcopy(item)
if item.name is not_set:
item.name = alias
if self.settings.str_path_separator in item.name:
raise ValueError(
'Item name must not contain str_path_separator which is configured for this Config -- {!r} -- '
'but {!r} does.'.format(self.settings.str_path_separator, item)
)
self._tree[item.name] = item
if item.name != alias:
if self.settings.str_path_separator in alias:
raise ValueError(
'Item alias must not contain str_path_separator which is configured for this Config -- {!r} --'
'but {!r} used for {!r} does.'.format(self.settings.str_path_separator, alias, item)
)
self._tree[alias] = item
item._section = self
self.dispatch_event(self.hooks.item_added_to_section, alias=alias, section=self, subject=item) | Add a config item to this section. |
def add_section(self, alias, section):
if not isinstance(alias, six.string_types):
raise TypeError('Section name must be a string, got a {!r}'.format(type(alias)))
self._tree[alias] = section
if self.settings.str_path_separator in alias:
raise ValueError(
'Section alias must not contain str_path_separator which is configured for this Config -- {!r} -- '
'but {!r} does.'.format(self.settings.str_path_separator, alias)
)
section._section = self
section._section_alias = alias
self.dispatch_event(self.hooks.section_added_to_section, alias=alias, section=self, subject=section) | Add a sub-section to this section. |
def _get_recursive_iterator(self, recursive=False):
names_yielded = set()
for obj_alias, obj in self._tree.items():
if obj.is_section:
if obj.alias in names_yielded:
continue
names_yielded.add(obj.alias)
yield (obj.alias,), obj
if not recursive:
continue
for sub_item_path, sub_item in obj._get_recursive_iterator(recursive=recursive):
yield (obj_alias,) + sub_item_path, sub_item
else:
# _tree contains duplicates so that we can have multiple aliases point
# to the same item. We have to de-duplicate here.
if obj.name in names_yielded:
continue
names_yielded.add(obj.name)
yield (obj.name,), obj | Basic recursive iterator whose only purpose is to yield all items
and sections in order, with their full paths as keys.
Main challenge is to de-duplicate items and sections which
have aliases.
Do not add any new features to this iterator, instead
build others that extend this one. |
def iter_all(self, recursive=False, path=None, key='path'):
if isinstance(key, six.string_types) or key is None:
if key in _iter_emitters:
emitter = _iter_emitters[key]
else:
raise ValueError('Invalid key {!r}'.format(key))
else:
emitter = lambda k, v, _, f=key: (f(k, v), v)
for p, obj in self._get_path_iterator(recursive=recursive, path=path):
yield emitter(p, obj, self.settings.str_path_separator) | Args:
recursive: if ``True``, recurse into sub-sections
path (tuple or string): optional path to limit iteration over.
key: ``path`` (default), ``str_path``, ``name``, ``None``, or a function to calculate the key from
``(k, v)`` tuple.
Returns:
iterator: iterator over ``(path, obj)`` pairs of all items and
sections contained in this section. |
def iter_sections(self, recursive=False, path=None, key='path'):
for x in self.iter_all(recursive=recursive, path=path, key=key):
if key is None:
if x.is_section:
yield x
elif x[1].is_section:
yield x | See :meth:`.iter_all` for standard iterator argument descriptions.
Returns:
iterator: iterator over ``(key, section)`` pairs of all sections
in this section (and sub-sections if ``recursive=True``). |
def reset(self):
for _, item in self.iter_items(recursive=True):
item.reset() | Recursively resets values of all items contained in this section
and its subsections to their default values. |
def is_default(self):
for _, item in self.iter_items(recursive=True):
if not item.is_default:
return False
return True | ``True`` if values of all config items in this section and its subsections
have their values equal to defaults or have no value set. |
def dump_values(self, with_defaults=True, dict_cls=dict, flat=False):
values = dict_cls()
if flat:
for str_path, item in self.iter_items(recursive=True, key='str_path'):
if item.has_value:
if with_defaults or not item.is_default:
values[str_path] = item.value
else:
for item_name, item in self._tree.items():
if is_config_section(item):
section_values = item.dump_values(with_defaults=with_defaults, dict_cls=dict_cls)
if section_values:
values[item_name] = section_values
else:
if item.has_value:
if with_defaults or not item.is_default:
values[item.name] = item.value
return values | Export values of all items contained in this section to a dictionary.
Items with no values set (and no defaults set if ``with_defaults=True``) will be excluded.
Returns:
dict: A dictionary of key-value pairs, where for sections values are dictionaries
of their contents. |
def load_values(self, dictionary, as_defaults=False, flat=False):
if flat:
# Deflatten the dictionary and then pass on to the normal case.
separator = self.settings.str_path_separator
flat_dictionary = dictionary
dictionary = collections.OrderedDict()
for k, v in flat_dictionary.items():
k_parts = k.split(separator)
c = dictionary
for i, kp in enumerate(k_parts):
if i >= len(k_parts) - 1:
c[kp] = v
else:
if kp not in c:
c[kp] = collections.OrderedDict()
c = c[kp]
for name, value in dictionary.items():
if name not in self:
if as_defaults:
if isinstance(value, dict):
self[name] = self.create_section()
self[name].load_values(value, as_defaults=as_defaults)
else:
self[name] = self.create_item(name, default=value)
else:
# Skip unknown names if not interpreting dictionary as defaults
pass
continue
resolution = self._get_item_or_section(name, handle_not_found=False)
if is_config_item(resolution):
if as_defaults:
resolution.default = value
else:
resolution.value = value
else:
resolution.load_values(value, as_defaults=as_defaults) | Import config values from a dictionary.
When ``as_defaults`` is set to ``True``, the values
imported will be set as defaults. This can be used to
declare the sections and items of configuration.
Values of sections and items in ``dictionary`` can be
dictionaries as well as instances of :class:`.Item` and
:class:`.Config`.
Args:
dictionary:
as_defaults: if ``True``, the imported values will be set as defaults. |
def create_section(self, *args, **kwargs):
kwargs.setdefault('section', self)
return self.settings.section_factory(*args, **kwargs) | Internal factory method used to create an instance of configuration section.
Should only be used when extending or modifying configmanager's functionality.
Under normal circumstances you should let configmanager create sections
and items when parsing configuration schemas.
Do not override this method. To customise section creation,
write your own section factory and pass it to Config through
section_factory= keyword argument. |
def get_path(self):
if not self.alias:
return ()
if self.section:
return self.section.get_path() + (self.alias,)
else:
return self.alias, | Calculate section's path in configuration tree.
Use this sparingly -- path is calculated by going up the configuration tree.
For a large number of sections, it is more efficient to use iterators that return paths
as keys.
Path value is stable only once the configuration tree is completely initialised. |
def item_attribute(self, f=None, name=None):
def decorator(func):
attr_name = name or func.__name__
if attr_name.startswith('_'):
raise RuntimeError('Invalid dynamic item attribute name -- should not start with an underscore')
self.__item_attributes[attr_name] = func
return func
if f is None:
return decorator
else:
return decorator(f) | A decorator to register a dynamic item attribute provider.
By default, uses function name for attribute name. Override that with ``name=``. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.