"""
Flask service to demonstrate how a web browser can subscribe to streaming
channel updates.
"""
import time, json, traceback, string, re, uuid
from flask import Flask, jsonify, Response, request, make_response, session
from memcache import Client
app = Flask(__name__)
app.secret_key = 'my secret!'
memcached_client = Client(["127.0.0.1:11211"], debug=1)
CHANNEL_KEYS = string.ascii_uppercase
@app.route('/')
def home_page():
"""
Dummy home page returning nothing.
"""
return ''
@app.route('/api/v1.0/stream', methods=['GET'])
def get_stream():
"""
Command line test:
$ curl -v --cookie-jar ~/tmp/curl.cookies \
-b ~/tmp/curl.cookies -N \
http://127.0.0.1:5000/api/v1.0/stream
"""
def __init__(self, config, section):
from memcache import Client
servers = config.get(section, 'memcache-server').split()
self.conn = Client(servers)
GPIO.output(plb_light, GPIO.LOW) GPIO.setup(act_light, GPIO.OUT) GPIO.output(act_light, GPIO.LOW) # The red LED (recording) is set to PWM as I want 2 grades in light; 20% for recording, 100% for recognizing voice rec_dim = 20 # the brightness of the LED in dimmed mode GPIO.setup(rec_light, GPIO.OUT) rec_light_pwm = GPIO.PWM(rec_light, 100) # create object for PWM at 100 Hertz rec_light_pwm.start(1) #Start very dim to show that Alexa is awake #Setup Alexa recorded = False servers = ["127.0.0.1:11211"] mc = Client(servers, debug=1) path = os.path.realpath(__file__).rstrip(os.path.basename(__file__)) #Variables p = "" position = 0 audioplaying = False button_pressed = False start = time.time() vad = webrtcvad.Vad(2) currVolume = 100 # constants VAD_SAMPLERATE = 16000 VAD_FRAME_MS = 30 VAD_PERIOD = (VAD_SAMPLERATE / 1000) * VAD_FRAME_MS
def setUp(self):
# TODO: unix socket server stuff
servers = ["127.0.0.1:11211"]
self.mc = Client(servers, debug=1)
from memcache import Client
from hashlib import md5
import settings
MEMCACHED = Client(settings.MEMCACHED_SERVERS)
def _get_version(namespace):
key = str(namespace)
version = MEMCACHED.get(key)
if not version:
version = 1
MEMCACHED.set(key, 1)
return version
def set(key, value, expire=3600, namespace=None):
if namespace:
version = _get_version(namespace)
key = md5('%s|%s|%s' % (namespace, version, key)).hexdigest()
else:
key = md5(key).hexdigest()
if expire:
MEMCACHED.set(key, value, expire)
else:
MEMCACHED.set(key, value)
return True
def get(key, namespace=None):
if namespace:
from flask import Flask, render_template, request, Response, jsonify, make_response, redirect, url_for
from flask_socketio import SocketIO, emit, join_room, leave_room, rooms, close_room
import string, random, time, os, base64
from memcache import Client
from threading import Timer
NUM_EACH = 9
NUM_CARDS = 2
GAME_LENGTH = "3:00"
app = Flask(__name__, template_folder='.', static_folder='.')
app.config['SECRET_KEY'] = 'secret!'
mc = Client(['127.0.0.1:11211'], debug=0)
socketio = SocketIO(app)
@app.route('/')
def root():
return render_template("index.html",
name=request.args.get("name", ""),
game_id=request.args.get("game_id", ""))
@socketio.on('join game')
def join_game(data):
game_id = data["id"]
master = False
game = mc.get(game_id)
if not game:
master = True
def __init__(self):
SessionHandler.inst = self
self.conn = Client(["127.0.0.1:11211"])
import tempfile
import time
import sys
import requests
from memcache import Client
from transitions import Machine
from alexapi.utils import check_network
from alexapi.utils import mrl_fix
import alexapi.pubsub as events
# constants
SERVERS = ["127.0.0.1:11211"]
MEMCACHE = Client(SERVERS, debug=1)
TMP_PATH = os.path.join(tempfile.mkdtemp(prefix='AlexaPi-AVS-'), '')
RES_PATH = os.path.join(
os.path.realpath(__file__).rstrip(os.path.basename(__file__)),
'../../resources', '')
class AVS(Component):
def __init__(self, config):
Component.__init__(self, config)
events.register('boot_requested', self.boot)
events.register('greetings_requested', self.greet)
events.register('detection_fullfilled', self.capture)
events.register('capture_fullfilled', self.process)
from memcache import Client cache = Client(['127.0.0.1:11211'])
from functools import wraps
from uuid import uuid4
from memcache import Client
servers = ["127.0.0.1:11211"]
user_cache = Client(servers)
def cache_decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
id = args[0]
if user_cache.get(str(id)):
value = user_cache.get(str(id))
print("FROM CACHE: user id={0}, some result: {1}".format(
str(id), value))
return True, value
result = func(*args, **kwargs)
user_cache.set(str(id), result)
return False, result
return wrapper
@cache_decorator
def get_long_response(user_id):
print("Starting heavy calculations...")
result = uuid4().hex
print("user id={0}, some result: {1}".format(user_id, result))
return result
import unicodedata
import rpc
from memcache import Client
import simplejson as json
mc = Client(["127.0.0.1:11211"], debug=1)
def get_dynamic_global_properties():
key = 'dgp'
dgp = mc.get(key)
if not dgp:
dgp = rpc.db_get_dynamic_global_properties()
mc.set(key, dgp, 60)
return dgp
def get_account(account_id):
key = '?account_%s' % account_id
account = mc.get(key)
if not account:
account = rpc.db_get_accounts([account_id])[0]
mc.set(key, account, 120)
return account
def get_block_header(block_num):
key = '?block_header%s' % block_num
block_header = mc.get(key)
if not block_header:
block_header = rpc.db_get_block_header(block_num)
from memcache import Client shared = Client(['127.0.0.1:11211'], debug=0, cache_cas=True)
from memcache import Client
cache = Client([("localhost", 11211), ("127.0.0.1", 11211)], debug=True)
def processing(self, filename, dry=False):
processed_counter = ProcessedAppsCounter()
pool = ThreadPool(self.max_threads)
device_memc_clients = dict()
memc_clients_buff = defaultdict(dict)
memc_clients_buff_size = defaultdict(int)
memc_clients_processed_apps = defaultdict(int)
def bufferize_appsinstalled(memc_client, appsinstalled):
ua = appsinstalled_pb2.UserApps()
ua.lat = appsinstalled.lat
ua.lon = appsinstalled.lon
key = "%s:%s" % (appsinstalled.dev_type, appsinstalled.dev_id)
ua.apps.extend(appsinstalled.apps)
packed = ua.SerializeToString()
memc_clients_buff_size[memc_client] += len(packed)
memc_clients_buff[memc_client].update({key: packed})
memc_clients_processed_apps[memc_client] += 1
return memc_clients_buff_size[memc_client]
logging.info('Processing %s' % filename)
for name, addr in self.device_memc.items():
device_memc_clients[name] = Client([addr], socket_timeout=TIMEOUT)
with gzip.open(filename) as fd:
for line in fd:
line = line.strip()
if not line:
continue
appsinstalled = parse_appsinstalled(line)
if not appsinstalled:
processed_counter.error()
continue
memc_client = device_memc_clients.get(appsinstalled.dev_type,
None)
if not memc_client:
processed_counter.error()
logging.error("Unknow device type: %s" %
appsinstalled.dev_type)
continue
# bufferize content and check buff size
if bufferize_appsinstalled(memc_client,
appsinstalled) > self.buff_max_size:
processed_counter.processed(
count=memc_clients_processed_apps[memc_client])
# Get shallow copy
bufferized_dict = memc_clients_buff[memc_client].copy()
# Clean original buff
memc_clients_buff[memc_client] = dict()
# Reset size buffer
memc_clients_buff_size[memc_client] = 0
# Reset processed apps
memc_clients_processed_apps[memc_client] = 0
# Add task to pool
def to_excecute():
return insert_appsinstalled(memc_client,
bufferized_dict, dry,
processed_counter)
pool.map(to_excecute, [])
# Send tailings from buffers
for memc_client, bufferized_dict in memc_clients_buff.items():
if memc_clients_buff_size[memc_client] > 0:
processed_counter.processed(
count=memc_clients_processed_apps[memc_client])
# Add task to pool
def to_excecute():
return insert_appsinstalled(memc_client,
bufferized_dict, dry,
processed_counter)
pool.map(to_excecute, [])
pool.close()
pool.join()
err_rate = processed_counter.get_errors_rate()
processed = processed_counter.get_processed()
if err_rate < NORMAL_ERR_RATE:
logging.debug("processed %s" % processed)
logging.info("Acceptable error rate (%s). Successfull load" %
err_rate)
else:
logging.error("High error rate (%s > %s). Failed load" %
(err_rate, NORMAL_ERR_RATE))
dot_rename(filename)
def __init__(self, servers=["127.0.0.1:11211"]):
self.__mc = Client(servers)
pass
