from datetime import datetime
from typing import Dict, List
from typing import Optional
from aenum import Enum
date_format = "%Y-%m-%dT%H:%M:%S.%f"
Currency = Enum('EUR', 'USD')
Branch = Enum('DIGITAL', 'CASH')
class Person(object):
id: int
name: str
email: Optional[str]
phone: Optional[str]
tags = []
added: datetime
changed: Optional[datetime]
def __init__(self, data: Dict):
tags = str(data['tags'])
tags = tags.replace('[', '')
tags = tags.replace(']', '')
tags = tags.replace('\'', '')
self.id = data['id']
self.name = data['name']
self.email = data['email']
self.phone = data['phone']
self.tags = tags
else:
self.traversers = iter(traversal.traversers)
if cb:
try:
result = cb(self)
except Exception as e:
future.set_exception(e)
else:
future.set_result(result)
else:
future.set_result(self)
future_traversal.add_done_callback(process)
return future
Barrier = Enum('Barrier', ' normSack')
statics.add_static('normSack', Barrier.normSack)
Cardinality = Enum('Cardinality', ' list_ set_ single')
statics.add_static('single', Cardinality.single)
statics.add_static('list_', Cardinality.list_)
statics.add_static('set_', Cardinality.set_)
Column = Enum('Column', ' keys values')
statics.add_static('keys', Column.keys)
statics.add_static('values', Column.values)
Direction = Enum('Direction', ' BOTH IN OUT')
import socket
import time
from collections import OrderedDict
from abc import ABC, abstractmethod
from aenum import Enum
from contextlib import closing
from olympe.arsdkng.backend import Backend
from olympe._private import callback_decorator
_DEFAULT_TIMEOUT = 2.0
DeviceState = Enum(
"DeviceState",
{
re.compile("^ARSDK_DEVICE_STATE_").sub("", v): k
for k, v in od.arsdk_device_state__enumvalues.items()
},
)
class Device(object):
def __init__(
self,
ip_addr,
serial="000000000000000000",
name="",
device_type=int(od.ARSDK_DEVICE_TYPE_UNKNOWN),
port=44444,
proto_v=1, # ARSDK_PROTOCOL_VERSION_1 is the safe default
state=None,
else:
self.traversers = iter(traversers)
if cb:
try:
result = cb(self)
except Exception as e:
future.set_exception(e)
else:
future.set_result(result)
else:
future.set_result(self)
future_traversers.add_done_callback(process)
return future
Barrier = Enum('Barrier', 'normSack')
statics.add_static('normSack', Barrier.normSack)
Cardinality = Enum('Cardinality', 'list_ set_ single')
statics.add_static('single', Cardinality.single)
statics.add_static('list_', Cardinality.list_)
statics.add_static('set_', Cardinality.set_)
Column = Enum('Column', 'keys values')
statics.add_static('keys', Column.keys)
statics.add_static('values', Column.values)
Direction = Enum('Direction', 'BOTH IN OUT')
statics.add_static('OUT', Direction.OUT)
statics.add_static('IN', Direction.IN)
statics.add_static('BOTH', Direction.BOTH)
from datetime import datetime
from collections import Callable
from aenum import Enum
from .user import User
prio_types = Enum("prio_types", "low default high critical")
class Message:
__content_type = "message"
def __init__(self, author: User, content: str, system: bool, append_allow: bool = True,
priority: prio_types = prio_types.default):
self.author = author
self.content = content
self.system = system
self.full_timestamp = datetime.now()
self.timestamp = self.full_timestamp.strftime("%H:%M:%S")
self.append_allow = append_allow
self.priority = priority
def to_json(self) -> dict:
return {
"content_type": self.__content_type,
"author": self.author.to_json(),
"content": self.content,
"system": self.system,
"full_timestamp": str(self.full_timestamp),
"timestamp": str(self.timestamp),
bigtext = '{0} LONGTEXT'
auto_increment = '{0} SERIAL'
primary_key = 'PRIMARY KEY ({0})'
index = 'CREATE INDEX IF NOT EXISTS {0}_idx ON {0}({1});'
create_table = 'CREATE TABLE IF NOT EXISTS'
insert = """INSERT INTO {0}({1})VALUES({2});"""
value_place_holder = '?'
DEFAULT_STR_LEN = 30
DEFAULT_DECIMAL_TOTAL_DIGITS = 10
DEFAULT_DECIMAL_FRACTION_DIGITS = 2
BIG_TEXT_MIN_LEN = 16000
INT_MIN_VALUE = -2147483648
INT_MAX_VALUE = 2147483647
WhiteSpaceBehaviour = Enum('WhiteSpaceBehaviour', 'PRESERVE REPLACE COLLAPSE')
class DataProperty(object):
def __init__(self, *args, **kwargs):
for k, v in kwargs.items():
#~ print( k, v )
if (v is not None):
setattr(self, k, v)
if not (hasattr(self, 'data_type')):
self.data_type = str
try:
self._name = self.fget.__name__
except AttributeError:
import attr
from aenum import Enum
from machinekit import hal
from machinekit import rtapi as rt
from machinekit import config as c
from pinconfig import io_map, pru0_input_pins
from servo import setup_servo
c.load_ini('hardware.ini')
PinDirection = Enum('PinDirection', 'IN OUT LOW HIGH')
@attr.s
class IOPin(object):
number = attr.ib(default='')
direction = attr.ib(default=PinDirection.IN)
def get_io_pin(id_, direction=PinDirection.IN):
port, pin = str(id_)[0], str(id_)[1:]
dir_ = 'in' if direction is PinDirection.IN else 'out'
return hal.pins['bb_gpio.p{}.{}-{}'.format(port, dir_, pin)]
def setup_storage():
hal.loadusr('hal_storage',
name='storage',
file='storage.ini',
from aenum import Enum
NodeTypes = Enum("NodeTypes", "article, blog, page, team, testimonials")
SpaceStatus = Enum(
"Status",
"Incomplete, Duplicate, Waiting, Published, Revoked, Filled, Unpublished, Unresponse, Blocked, Test, Spam"
)
from __future__ import print_function
"""
Conway's Game of Life based Cell.
"""
from aenum import Enum
from cellplayground.playground.cell import Cell
State = Enum('State', 'DEAD ALIVE')
class ConwayCell(Cell):
state = State.DEAD
def __init__(self, **kwargs):
super(ConwayCell, self).__init__(**kwargs)
def play(self, playground):
"""
Plays along with standard Game of Life rules. Which are:
1. 2d playground
2. Look in neighborhood:
if < 2 neighbors, die (under-population)
if 2, 3 neighbors, live
if > 3 die (over-population)
empty cells get populated if == 3 neighbors
(but that's handled by the ConwayPlayground)
"""
if playground is None:
raise ValueError("No playground for this cell!")
num_live_neighbors = 0
neighbors = playground.neighborhood(self.x, self.y)
# of its contributors may be used to endorse or promote products
# derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# PARROT COMPANY BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
# SUCH DAMAGE.
from aenum import Enum
import re
import olympe_deps as od
VMetaFrameType = Enum(
'VMetaFrameType', {
re.compile('^VMETA_FRAME_TYPE_').sub('', v): k
for k, v in od.vmeta_frame_type__enumvalues.items()
})
PDRAW_LOCAL_STREAM_PORT = 55004
PDRAW_LOCAL_CONTROL_PORT = 55005
PDRAW_TIMESCALE = 1000000 # 1µ
def _load_definition(path):
with open(path) as file:
return json.load(file)
class _Schemas(Enum):
"""Base class for supported transliteration schemas."""
@classmethod
def names(cls):
"""Return names of all supported schemas."""
return sorted(item.name for item in cls)
@classmethod
def items(cls):
"""Return all supported schemas."""
return [(item.name, item.value) for item in sorted(cls, key=attrgetter("value.name"))]
@classmethod
def get(cls, name):
"""Return schema by its name or ``None`` if nothing found."""
item = cls.__members__.get(name)
return item.value if item else None
# All supported transliteration schemas
# pylint: disable=invalid-name
Schemas = Enum( # type: ignore
"Schemas", [(schema.name, schema) for schema in _schema_loader()], type=_Schemas
)
from typing import List, Union
from datetime import datetime
from collections.abc import Iterable
from aenum import Enum
from .user import User, get_sys_user
media_types = Enum("media_types", "img video audio gif")
class Field:
def __init__(self, topic: str, value: str):
self.topic = topic
self.value = value
def to_json(self) -> dict:
return {"topic": self.topic, "value": self.value}
class Media:
def __init__(self, media_type: media_types, media_url: str):
self.media_type = media_type
self.media_url = media_url
def to_json(self) -> dict:
return {
"media_type": self.media_type.name,
"media_url": self.media_url
}
from aenum import Enum
# ENCRYPTION
BLOCK_SIZE = 16 # aes data block size in bytes
SESSION_KEY_SIZES = [128, 192,
256] # key for aes can be 128, 192 or 256 bits long
PARM_ALG_TYPE_LEN = 4 # length of an algorithm type parameter in bits
PARM_SESS_KEY_SIZE_LEN = 2 # length of a session key size parameter in bits
PARM_BLOCK_SIZE_LEN = 8 # length of a block size parameter in bits
PARM_CIPHER_MODE_LEN = 2 # length of a cipher mode parameter in bits
PARM_LEN = (PARM_ALG_TYPE_LEN + PARM_SESS_KEY_SIZE_LEN + PARM_BLOCK_SIZE_LEN +
PARM_CIPHER_MODE_LEN) // 8 # length of
# a parameters message header in bytes
FILE_PERCENT_LEN = 8 # length of a percent size parameter in file message in bits
# COMMUNICATION
SOCKET_BUFSIZE = BLOCK_SIZE * 256 # maximum amount of data to be received at once by socket
SOCKET_HEADLEN = 8 # length of a socket message header (message type, message length) in bytes
SOCKET_HEADFORMAT = '4sL' # formatting of a socket message header, 4s - 4 chars (bytes); L - unsigned long
# SHARED
BLOCK_CIPHER_MODE = Enum(value='BlockCipherMode',
names={
'ECB': 'ECB',
'CBC': 'CBC',
'CFB': 'CFB',
'OFB': 'OFB'
})
from aenum import Enum
DetectionState = Enum('DetectionState', "ok detected failed")
DetectionTransition = Enum('DetectionTransition',
"ok detected failed recovered")
DisplayState = Enum('DisplayState',
"loading ok warn0 warn1 warned0 warned1 failed")
DisplayTransition = Enum('DisplayTransition',
"loaded ok warn failed recovered")
import numpy as np
from aenum import Enum
import logging
Status = Enum('Status', 'EMPTY READY SOLVED ERROR')
class Searcher:
_model = None
_obj_func_key = None
_prefix_id = None
_status = Status.EMPTY
_solutions = None
def __init__(self, model, obj_func_key="obj_func", pre_id=""):
# if isinstance(model, type(Model)):
# error_message = "The parsed model is not acceptable." \
# " Item must be a lpmodel.Model() instance, type found: {0}".format(type(model))
# raise IOError(error_message)
self._model = model
self._obj_func_key = obj_func_key
self._solutions = []
self._status = Status.READY
self._prefix_id = pre_id
self._model.prefix_id = pre_id
def refine_bounds(self, lb=0.0, ub=1.0, tol=0.01):
new_lb = self.refine_bound(lb, ub, direction=1, tol=tol)
new_ub = self.refine_bound(lb, ub, direction=-1, tol=tol)
import nvector as nv
from aenum import Enum
from math import fabs
from geopy.distance import vincenty as vc
from numpy.linalg import norm
from math import cos, sin, acos, degrees, atan2, radians
from itertools import chain
import cmath
import gmplot
# Enum to represent position of a point with respect to a path
PositionOnPath = Enum('PositionOnPath', 'NotOnPathOnCircle OnPath NotOnCircle')
# Constants
EARTH_RADIUS = 6371e3
def crosstrack_distance(a1, a2, b):
frame = nv.FrameE(a=EARTH_RADIUS, f=0)
pointA1 = frame.GeoPoint(a1[0], a1[1], degrees=True)
pointA2 = frame.GeoPoint(a2[0], a2[1], degrees=True)
pointB = frame.GeoPoint(b[0], b[1], degrees=True)
pathA = nv.GeoPath(pointA1, pointA2)
cr_distance = pathA.cross_track_distance(pointB,
method='greatcircle').ravel()
return cr_distance[0]
def closest_point_on_circle(a1, a2, b):
frame = nv.FrameE(a=EARTH_RADIUS, f=0)
pointA1 = frame.GeoPoint(a1[0], a1[1], degrees=True)