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()
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
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
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',
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,
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
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
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')
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
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())
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=[{