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)