def test_dict_ops():
    ed = ExpiringDict()
    ed["one"] = 1
    ed["two"] = 2
    ed["three"] = 3
    d = dict()
    d["one"] = 1
    d["two"] = 2
    d["three"] = 3
    assert [x for x in d] == [x for x in ed]
    assert [k for k in d.keys()] == [k for k in ed.keys()]
    assert [v for v in d.values()] == [v for v in ed.values()]
    assert [i for i in d.items()] == [i for i in ed.items()]
    assert "one" in ed
    def __init__(self, host=None, port=None, max_clients=None):
        if not host:
            host = os.getenv('HOST', '0.0.0.0')
        if not port:
            port = os.getenv('PORT', 31337)
        if not max_clients:
            max_clients = os.getenv('MAX_CLIENTS', 15)
        self._pool = Pool(int(max_clients))
        self._server = StreamServer((host, int(port)),
                                    self.connection_handler,
                                    spawn=self._pool)

        self._protocol = DataHandler()
        self._kv = ExpiringDict()

        self._commands = self.get_commands()
Example #3
0
import os
import pprint
import boto3
import uuid
import requests
import logging

NUM_DISCOUNTS = 2

EXPERIMENTATION_LOGGING = True
DEBUG_LOGGING = True

# Since the DescribeCampaign API easily throttles and we just need
# the recipe from the campaign and it won't change often (if at all),
# use a cache to help smooth out periods where we get throttled.
personalize_meta_cache = ExpiringDict(2 * 60 * 60)

servicediscovery = boto3.client('servicediscovery')
personalize = boto3.client('personalize')
ssm = boto3.client('ssm')
codepipeline = boto3.client('codepipeline')
sts = boto3.client('sts')
cw_events = boto3.client('events')

# SSM parameter name for the Personalize filter for purchased items
filter_purchased_param_name = 'retaildemostore-personalize-filter-purchased-arn'

training_config_param_name = 'retaildemostore-training-config'  # ParameterPersonalizeTrainConfig
dataset_group_name_root = 'retaildemostore-'

# -- Shared Functions
Example #4
0
import requests
import threading
import signal
import logging
import time
from flask import request
import json
from expiring_dict import ExpiringDict
import time

app = Flask(__name__)

access_token = ""
logger = logging.getLogger(__name__)

channels = ExpiringDict(300)
broadcasters = ExpiringDict(300)

CLIENT_ID = "ao93ev500wqpaczsn55vca74kli26z"
CLIENT_SECRETE = "wdcac9rjzje6lwxczkffwz1woj5iw9"


@app.before_first_request
def activate_job():
    def run_job():
        while True:
            get_access_token()
            time.sleep(60)

    thread = threading.Thread(target=run_job)
    thread.start()
def test_no_ttl():
    d = ExpiringDict()
    d["key"] = "value"
    assert len(d._ExpiringDict__expirations) == 0
def test_init():
    ExpiringDict()
def test_set_ttl():
    d = ExpiringDict()
    d.ttl("key", "expire", 1)
    assert len(d) == 1
    sleep(1.1)
    assert len(d) == 0
Example #8
0
update. We use etags and a cache to avoid refetching things that have not
changed.
"""
tracemalloc.start(25)

TRACE = False
HARVEST_TTL = 60
HARVEST_TTL_INTERVAL = 5

logger = logging.getLogger(__name__)

# A dictionary to hold our data
# In order to avoid memory leakage, we need to expire items
# in this cache after HARVEST_TTL seconds
# We should check for things to expire every HARVEST_TTL_INTERVAL seconds
harvest_dict = ExpiringDict(ttl=HARVEST_TTL, interval=HARVEST_TTL_INTERVAL)

# TODO: update when this is updated upstream
# https://github.com/clearlydefined/service/blob/master/schemas/definition-1.0.json#L17
known_types = (
    # None gets _all definitions_ from the definition endpoint.
    # None,
    'npm',
    # 'git',
    # 'pypi',
    # 'composer',
    # 'maven',
    # 'gem',
    # 'nuget',
    # 'sourcearchive',
    # 'deb',
Example #9
0
from fastapi_playground.logger import NoHealth, get_basic_logger
from os import environ
import random
from time import perf_counter

import uvicorn
from fastapi import FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware
from starlette.config import Config
from expiring_dict import ExpiringDict

known_cookies = ExpiringDict(600)

logger = get_basic_logger(__name__, 'DEBUG')
logger.addFilter(NoHealth())
"""
one of our dependencies probably locked the seed somewhere.
However, I actually need the global random.
If unlocking the random seed breaks your code,
you should create a new random instance and lock only the one you created
"""
random.seed()

# For deployment. SCRIPT_NAME is the root path of uvicorn.
# https://fastapi.tiangolo.com/advanced/behind-a-proxy/
SCRIPT_NAME = Config()('SCRIPT_NAME', default='')

TITLE = 'Sticky Session Demo'

app = FastAPI(
    title=TITLE,
Example #10
0
def test_set_ttl():
    d = ExpiringDict(interval=0.005)
    d.ttl("key", "expire", 0.01)
    assert len(d) == 1
    sleep(0.02)
    assert len(d) == 0
Example #11
0
def test_class_ttl():
    d = ExpiringDict(ttl=0.01, interval=0.005)
    d["key"] = "should be gone"
    assert len(d) == 1
    sleep(0.02)
    assert len(d) == 0
# SPDX-License-Identifier: MIT-0

import boto3
import os
import json
import logging
from typing import Dict,List
from expiring_dict import ExpiringDict
from experimentation.features import FEATURE_NAMES
from experimentation.experiment_evidently import EvidentlyExperiment

log = logging.getLogger(__name__)

evidently = boto3.client('evidently')
# Cache feature evals for 30 seconds to balance latency and timeliness of picking up experiments
eval_features_by_user_cache = ExpiringDict(30)

project_name = os.environ['EVIDENTLY_PROJECT_NAME']

class EvidentlyFeatureResolver:
    """
    This class is used by ExperimentManager to determine if an Evidently experiment is active
    for a feature as well as for mapping a correlation ID to an EvidentlyExperiment instance for logging outcomes.
    """

    def evaluate_feature(self, user_id: str, feature: str) -> EvidentlyExperiment:
        """ Evaluates a storefront feature for a user
        An EvidentlyExperiment will be returned if there is an active Evidently experiment for the feature or
        None if an experiment is not active.
        """
        cache_key = user_id
Example #13
0
import logging

import vk_api
from vk_api.bot_longpoll import VkBotLongPoll
from vk_api.upload import VkUpload
from vk_api.bot_longpoll import VkBotEventType
from vk_api.keyboard import VkKeyboard, VkKeyboardColor

from expiring_dict import ExpiringDict
import COVID19Py

keyboard = VkKeyboard(one_time=False)
keyboard.add_button('Коронавирус в мире', color=VkKeyboardColor.PRIMARY)
keyboard.add_button('Коронавирус в россии', color=VkKeyboardColor.PRIMARY)

corona_dict = ExpiringDict(max_len=2, max_age_seconds=3600)
covid19 = COVID19Py.COVID19()

vk_session = vk_api.VkApi(token=os.getenv('TOKEN'), api_version='5.95')
vk = vk_session.get_api()
longpoll = VkBotLongPoll(vk_session, os.getenv('GROUP_ID'))
upload = VkUpload(vk_session)

logging.basicConfig(format='%(levelname)s %(name)s [%(asctime)s]: %(message)s',
                    datefmt='%d:%m:%Y:%H:%M:%S')

log = logging.getLogger(__name__)
log.setLevel(logging.INFO)
log.info('start')

Example #14
0
from time import sleep
from expiring_dict import ExpiringDict

cache = ExpiringDict()  # No TTL set, keys set via [] will not expire

cache["abc"] = "persistent"
cache.ttl("123", "expires", 1)  # This will expire after 1 second
print("abc" in cache)
print("123" in cache)
sleep(1.1)
print("abc" in cache)
print("123" not in cache)

cache2 = ExpiringDict(1)

cache2["abc"] = "expires"
cache2["123"] = "also expires"
print("abc" in cache2)
print("123" in cache2)
sleep(1.1)
print("abc" not in cache2)
print("123" not in cache2)
def test_class_ttl():
    d = ExpiringDict(ttl=1)
    d["key"] = "should be gone"
    assert len(d) == 1
    sleep(1.1)
    assert len(d) == 0
Example #16
0
    history_data_columns: List[str] = []
    admin_users_data_columns: List[str] = []
    ui: UIConfig = None
    track_history_endpoints: List[str] = [
        "model_delete",
        "model_delete_all",
        "model_edit_post",
        "model_add",
        "presets_use",
        "init_db_run",
        "file_upload",
        "sql_query_run",
        "login",
        "logout_post",
    ]
    hide_columns: List[Any] = []

    @validator("displayable_setting")
    def displayable_setting_cannot_be_changed(cls, value):
        return ["presets_folder", "composite_csv_settings", "name"]

    class Config(BaseConfig):
        arbitrary_types_allowed = True


# instance of config on current run
cfg = Config()
cfg.sessions = ExpiringDict(ttl=3600)
cfg.jinja = jinja
cfg.ui = UIConfig(colors=ColorSchema())
Example #17
0
import boto3
import os
import random

from botocore.exceptions import ClientError
from aws_lambda_powertools import Logger
from expiring_dict import ExpiringDict

logger = Logger(child=True)

_clients_by_region = {}
# Since the DescribeCampaign API easily throttles and we just need
# the minProvisionedTPS from the campaign, use a cache to help smooth
# out periods where we get throttled.
_campaign_cache = ExpiringDict(22 * 60)

PROJECT_NAME = 'PersonalizeMonitor'
ALARM_NAME_PREFIX = PROJECT_NAME + '-'


def put_event(detail_type, detail, resources=[]):
    event_bridge = get_client('events')

    logger.info({
        'detail_type': detail_type,
        'detail': detail,
        'resources': resources
    })

    event_bridge.put_events(Entries=[{