def create_table(cls, fail_silently=False):
cls.__fields__ = list(cls.__schema__.keys())
cls.Row = namedtuple(cls.__table__, cls.__fields__)
try:
os.makedirs("%s/%s" % (cls.__db__.name, cls.__table__))
except OSError as e:
if fail_silently:
print(e)
else:
raise
def __init__(self, seed, action_size):
"""
initialize the replaybuffer
:param seed: random seed for replaybuffer
:param action_size: dimension of agent action
"""
self.seed = random.seed(seed)
self.action_size = action_size
self.memory = deque(maxlen=BUFFER_SIZE)
self.experience = namedtuple("Experience", field_names=["state", "action", "reward", "next_state", 'done'])
def _parse_args(self, args):
# add optional args with defaults
arg_dest = []
arg_vals = []
for opt in self.opt:
arg_dest.append(opt.dest)
arg_vals.append(opt.default)
# parse all args
parsed_pos = False
while args or not parsed_pos:
if args and args[0].startswith("-") and args[0] != "-" and args[0] != "--":
# optional arg
a = args.pop(0)
if a in ("-h", "--help"):
self.usage(True)
sys.exit(0)
found = False
for i, opt in enumerate(self.opt):
if a == opt.name:
arg_vals[i] = opt.parse(args)
found = True
break
if not found:
raise _ArgError("unknown option %s" % a)
else:
# positional arg
if parsed_pos:
raise _ArgError("extra args: %s" % " ".join(args))
for pos in self.pos:
arg_dest.append(pos.dest)
arg_vals.append(pos.parse(args))
parsed_pos = True
# build and return named tuple with arg values
return namedtuple("args", arg_dest)(*arg_vals)
import bench
from _collections import namedtuple
T = namedtuple("Tup", "foo1 foo2 foo3 foo4 num")
def test(num):
t = T(0, 0, 0, 0, 20000000)
i = 0
while i < t.num:
i += 1
bench.run(test)
import bench
from _collections import namedtuple
T = namedtuple("Tup", ["foo1", "foo2", "foo3", "foo4", "num"])
def test(num):
t = T(0, 0, 0, 0, 20000000)
i = 0
while i < t.num:
i += 1
bench.run(test)
import bench
from _collections import namedtuple
T = namedtuple("Tup", "foo1 foo2 foo3 foo4 num")
def test(num):
t = T(0, 0, 0, 0, 20000000)
i = 0
while i < t.num:
i += 1
bench.run(test)
import bench
from _collections import namedtuple
T = namedtuple("Tup", "num bar")
def test(num):
t = T(20000000, 0)
i = 0
while i < t.num:
i += 1
bench.run(test)
from _collections import namedtuple
a = namedtuple('courses', 'name, tech, place')
s = a('mahesh', 'python', 'delhi')
t = a._make(['neha', 'go', 'delhi'])
print(s)
print(t)
#####################################################################
from _collections import deque
a = ['e', 'd', 'u', 't', 'a', 'm', 'h']
d = deque(a)
d.appendleft('w') #append at begining
d.append('w') #append at last
print(d)
d.pop() #pop from last
d.popleft() #pop from start
print(d)
#####################################################################
from _collections import ChainMap
a = {1: 'Mahesh', 2: 'Python'}
a = {1: 'Neha', 2: 'GoLang'}
c = ChainMap(a, b)
import bench
from _collections import namedtuple
T = namedtuple("Tup", "num bar")
def test(num):
t = T(20000000, 0)
i = 0
while i < t.num:
i += 1
bench.run(test)
import bench
from _collections import namedtuple
T = namedtuple("Tup", ["num", "bar"])
def test(num):
t = T(20000000, 0)
i = 0
while i < t.num:
i += 1
bench.run(test)
import bench
from _collections import namedtuple
T = namedtuple("Tup", ["foo1", "foo2", "foo3", "foo4", "num"])
def test(num):
t = T(0, 0, 0, 0, 20000000)
i = 0
while i < t.num:
i += 1
bench.run(test)
__all__ = ["open", "openfp", "Error"]
class Error(Exception):
pass
WAVE_FORMAT_PCM = 0x0001
_array_fmts = None, 'b', 'h', None, 'i'
#import audioop
import struct
import sys
from chunk import Chunk
from _collections import namedtuple
_wave_params = namedtuple('_wave_params',
'nchannels sampwidth framerate nframes comptype compname')
class Wave_read:
"""Variables used in this class:
These variables are available to the user though appropriate
methods of this class:
_file -- the open file with methods read(), close(), and seek()
set through the __init__() method
_nchannels -- the number of audio channels
available through the getnchannels() method
_nframes -- the number of audio frames
available through the getnframes() method
_sampwidth -- the number of bytes per audio sample
available through the getsampwidth() method
_framerate -- the sampling frequency
class WS2812(SubscriptableForPixel):
# Driver for WS2812 RGB LEDs. May be used for controlling single LED or chain
# of LEDs.
#
# Examples of use:
#
# chain = WS2812(spi_bus=1, led_count=4)
# i = 0
# for pixel in chain:
# pixel.r = i
# pixel.g = i + 1
# pixel.b = i + 2
# i += 3
# chain.sync()
#
# chain = WS2812(spi_bus=1, led_count=4)
# data = [
# (255, 0, 0), # red
# (0, 255, 0), # green
# (0, 0, 255), # blue
# (85, 85, 85), # white
# ]
# chain.show(data)
#
# Version: 1.5
buf_bytes = (0x11, 0x13, 0x31, 0x33)
ReadOnlyPixel = namedtuple('Pixel', 'r g b')
def __init__(self, spi_bus=1, led_count=1, intensity=1, mem=PREALLOCATE):
#Params:
# spi_bus = SPI bus ID (1 or 2)
# led_count = count of LEDs
# intensity = light intensity (float up to 1)
# mem = how stingy to be with memory (comes at a speed & GC cost)
self.led_count = led_count
self.intensity = intensity # FIXME: intensity is ignored
self.mem = mem
# 0 prealloc
# 1 cache
# 2 create Pixel each time
# prepare SPI data buffer (4 bytes for each color for each pixel,
# with an additional zero byte at the end to make sure the data line
# comes to rest low)
self.buf = bytearray(4 * 3 * led_count + 1)
if mem <= CACHE:
# Prepare a cache by index of Pixel objects
self.pixels = pixels = [None] * led_count
if mem == PREALLOCATE: # Pre-allocate the pixels
for i in range(led_count):
pixels[i] = Pixel(self.buf, 3 * i)
# OBSOLETE
#self.bits = array('L', range(256))
#bb = bytearray_at(addressof(self.bits), 4*256)
#mask = 0x03
#buf_bytes = self.buf_bytes
#for i in range(256):
# index = 4*i
# bb[index] = buf_bytes[i >> 6 & 0x03]
# bb[index+1] = buf_bytes[i >> 4 & 0x03]
# bb[index+2] = buf_bytes[i >> 2 & 0x03]
# bb[index+3] = buf_bytes[i & 0x03]
# SPI init
self.spi = pyb.SPI(spi_bus,
pyb.SPI.MASTER,
baudrate=3200000,
polarity=0,
phase=1)
# turn LEDs off
self.show([])
def __len__(self):
return self.led_count
def get_led_values(self, index, rgb=None):
# The asm function is unguarded as to index, so enforce here
if index >= self.led_count or index < -self.led_count:
raise IndexError("tried to get values at", index)
ix = index * 3
return self.ReadOnlyPixel(_get(self.buf, ix+1), \
_get(self.buf, ix+0), \
_get(self.buf, ix+2))
def show(self, data):
# Show RGB data on LEDs. Expected data = [(R, G, B), ...] where R, G and B
# are intensities of colors in range from 0 to 255. One RGB tuple for each
# LED. Count of tuples may be less than count of connected LEDs.
self.fill_buf(data)
self.send_buf()
def send_buf(self):
#Send buffer over SPI.
self.spi.send(self.buf)
def sync(self, to=None):
if to is None:
self.spi.send(self.buf)
else:
short_buf = bytearray_at(addressof(self.buf),
3 * 4 * to + 1) # extra byte
t = short_buf[-1]
short_buf[-1] = 0
self.spi.send(short_buf)
short_buf[-1] = t
_ubb = bytearray(3)
def update_buf(self, data, where=0):
# Fill a part of the buffer with RGB data.
# Returns the index of the first unfilled LED
# data is an iterable that returns an iterable
# e.g. [(1,2,3), (4,5,6)]
# or some generator of tuples or generators
set_led = self.set_led
b = self._ubb
for d in data:
if not isinstance(d, bytearray):
b[0], b[1], b[2] = d
d = b
set_led(where, d)
where += 1
return where
def fill_buf(self, data):
# Fill buffer with RGB data.
# All LEDs after the data are turned off.
end = self.update_buf(data)
# turn off the rest of the LEDs
#b = self.buf
#for i in range(4*3*end, 4*3*self.led_count):
# b[i] = 0x11 # off
_clearLEDs(self.buf, end, self.led_count - end)
