def __init__(self, config):
db = Gino(model_classes=tuple(gtfs_model.tables))
app = web.Application(middlewares=[db])
# I don't quite get why aiohttp says I shouldn't just use self.config
# for this, but whatever
app["config"] = config
app["aiocache"] = SimpleMemoryCache()
app["ansiconv"] = ansi2html.converter.Ansi2HTMLConverter(
linkify=True, title="curlbus", font_size='16px')
app['siriclient'] = SIRIClient(config["mot"]["url"],
config["mot"]["user_id"])
db.init_app(app)
app.router.add_static(
"/static/", os.path.join(os.path.dirname(__file__), '..',
"static"))
app.add_routes([
web.get('/{stop_code:\d+}{tail:/*}', self.handle_station),
web.get('/operators{tail:/*}', self.handle_operator_index),
web.get('/nearby', self.handle_nearby),
web.get('/{operator:\w+}{tail:/*}', self.handle_operator),
web.get('/rail/stations{tail:/*}', self.handle_rail_stations),
web.get('/rail/map{tail:/*}', self.handle_rail_map),
web.get('/operators/{operator}/{route_number}{tail:/*}',
self.handle_route),
web.get(
'/operators/{operator}/{route_number}/{alternative}{tail:/*}',
self.handle_route),
web.get('/operators/{operator}{tail:/*}', self.handle_operator),
web.get('/{operator}/{route_number}{tail:/*}', self.handle_route),
web.get('/{operator}/{route_number}/{alternative}{tail:/*}',
self.handle_route),
web.get('/{tail:/*}', self.handle_index)
])
self._app = app
async def test_invalid_json_retry_failure(aresponses):
"""Test a failed retry after getting a failed JSON error.
Note that we have to bust the cache before executing this test since all tests use
the same event loop.
"""
cache = SimpleMemoryCache()
await cache.delete(DEFAULT_CACHE_KEY)
aresponses.add(
"wwlln.net",
"/new/map/data/current.json",
"get",
aresponses.Response(text="This isn't JSON", status=200),
)
aresponses.add(
"wwlln.net",
"/new/map/data/current.json",
"get",
aresponses.Response(text="This isn't JSON", status=200),
)
with pytest.raises(RequestError):
async with aiohttp.ClientSession() as session:
client = Client(session=session)
await client.dump()
async def test_invalid_json_retry_successful(aresponses, dump_response):
"""Test a successful retry after getting a failed JSON error.
Note that we have to bust the cache before executing this test since all tests use
the same event loop.
"""
cache = SimpleMemoryCache()
await cache.delete(DEFAULT_CACHE_KEY)
aresponses.add(
"wwlln.net",
"/new/map/data/current.json",
"get",
aresponses.Response(text="This isn't JSON", status=200),
)
aresponses.add(
"wwlln.net",
"/new/map/data/current.json",
"get",
aresponses.Response(text=json.dumps(dump_response), status=200),
)
async with aiohttp.ClientSession() as session:
client = Client(session=session)
data = await client.dump()
assert len(data) == 6
async def test_caching(aresponses, dump_response):
"""Test that the caching mechanism works properly.
Note that we have to bust the cache before executing this test since all tests use
the same event loop.
"""
aresponses.add(
"wwlln.net",
"/new/map/data/current.json",
"get",
aresponses.Response(text=json.dumps(dump_response), status=200),
)
cache = SimpleMemoryCache()
await cache.delete(DEFAULT_CACHE_KEY)
async with aiohttp.ClientSession() as session:
client = Client(session=session)
cache_exists = await cache.exists(DEFAULT_CACHE_KEY)
assert not cache_exists
await client.within_radius(TEST_LATITUDE, TEST_LONGITUDE,
TEST_RADIUS_METRIC)
cache_exists = await cache.exists(DEFAULT_CACHE_KEY)
assert cache_exists
def __init__(self, url: str, user_id: str, cache: BaseCache=None,
cache_ttl: int=60, verbose: bool=False):
self.url = url
self.user_id = user_id
self.verbose = verbose
self.cache_ttl = cache_ttl
self._cache = cache if cache is not None else SimpleMemoryCache()
self._connector = None
def memory_mock_cache(mocker):
cache = SimpleMemoryCache()
mocker.spy(cache, 'multi_set')
mocker.spy(cache, 'multi_get')
mocker.spy(cache, 'get')
mocker.spy(cache, 'exists')
mocker.spy(cache, 'set')
yield cache
SimpleMemoryBackend._cache = {}
def init_cache(app, loop):
'''
初始化操作，对一些参数进行配置
:param app:
:return
'''
app.config['monkey_config'] = Config
app.cache = SimpleMemoryCache()
app.mongo_db = MotorBase(loop=loop).get_db()
def init_cache(app, loop):
"""
初始化操作 对一些参数进行配置
:param app:
:param loop:
:return:
"""
app.config["monkey_config"] = Config
app.cache = SimpleMemoryCache()
app.mongo_db = MotorBase(loop=loop).get_db()
def memory_cache(event_loop):
cache = SimpleMemoryCache(namespace="test")
cache.set_policy(DefaultPolicy)
yield cache
event_loop.run_until_complete(cache.delete(pytest.KEY))
event_loop.run_until_complete(cache.delete(pytest.KEY_1))
async def cache_from_registry(beacons, response):
"""Cache Beacon URLs that were received from Registry's update message."""
LOG.debug('Caching Beacons from Registry\'s update message.')
try:
cache = SimpleMemoryCache()
await cache.set('beacon_urls', beacons)
LOG.debug('Cache was set.')
except Exception as e:
response = 500
LOG.error(f'Couldn\'t set cache: {e}.')
return response
def memory_cache(event_loop):
cache = SimpleMemoryCache(namespace="test")
yield cache
event_loop.run_until_complete(cache.delete(pytest.KEY))
event_loop.run_until_complete(cache.delete(pytest.KEY_1))
event_loop.run_until_complete(cache.delete(pytest.KEY + '-lock'))
event_loop.run_until_complete(cache.close())
async def clear_cache():
"""Clear cache of Beacons."""
LOG.debug('Check if cache of Beacons exists.')
try:
cache = SimpleMemoryCache()
if await cache.exists("beacon_urls"):
LOG.debug('Found old cache.')
await cache.delete("beacon_urls")
LOG.debug('Cache has been cleared.')
else:
LOG.debug('No old cache found.')
await cache.close()
except Exception as e:
LOG.error(f'Error at clearing cache: {e}.')
async def test_no_explicit_session(aresponses, dump_response):
"""Test an API call with no explicitly-provided aiohttp ClientSession.
Note that we have to bust the cache before executing this test since all tests use
the same event loop.
"""
cache = SimpleMemoryCache()
await cache.delete(DEFAULT_CACHE_KEY)
aresponses.add(
"wwlln.net",
"/new/map/data/current.json",
"get",
aresponses.Response(text=json.dumps(dump_response), status=200),
)
client = Client()
data = await client.dump()
assert len(data) == 6
async def new_search(request):
upload_image = request.files.get("image")
if not upload_image:
raise NotFound(message='not image file')
image_types = ['image/jpeg', 'image/jpg', 'image/png']
if upload_image.type not in image_types:
raise NotFound(message='not image file')
upload_image_type = upload_image.type.split('/')[-1]
file_name = str(time.time())[:10] + '.' + upload_image_type
file_path = upload_image_path + file_name
with open(file_path, "wb") as f:
f.write(request.files["image"][0].body)
search_results = image_search(file_path)[:5]
cache = SimpleMemoryCache(serializer=JsonSerializer())
response_dict = {
'site_name': site_name,
'upload_image': file_name,
'search_results': search_results
}
await cache.set("response_dict", response_dict)
return response_dict
async def test_within_window(aresponses, dump_response):
"""Test retrieving the nearest strikes within a 10-minute window."""
# Bust the cache since we're parametrizing the input data:
cache = SimpleMemoryCache()
await cache.delete(DEFAULT_CACHE_KEY)
aresponses.add(
"wwlln.net",
"/new/map/data/current.json",
"get",
aresponses.Response(text=json.dumps(dump_response), status=200),
)
async with aiohttp.ClientSession() as session:
client = Client(session=session)
data = await client.within_radius(
TEST_LATITUDE,
TEST_LONGITUDE,
TEST_RADIUS_METRIC,
window=timedelta(minutes=10),
)
assert len(data) == 1
""" Copyright 2017-2020 Government of Canada - Public Services and Procurement Canada - buyandsell.gc.ca Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ from aiocache import SimpleMemoryCache MEM_CACHE = SimpleMemoryCache()
def test_default_serializer(self):
assert isinstance(SimpleMemoryCache().serializer, NullSerializer)
def test_inheritance(self):
assert isinstance(SimpleMemoryCache(), BaseCache)
async def test_accept_explicit_args(self):
with pytest.raises(TypeError):
SimpleMemoryCache(random_attr="wtf")
def setup_cache():
cache = SimpleMemoryCache(ttl=10)
return cache
def test_parse_uri_path(self):
assert SimpleMemoryCache().parse_uri_path("/1/2/3") == {}
import asyncio
import logging
from random import randint
import aiohttp
import discord
from aiocache import cached, SimpleMemoryCache
from api.expected_errors import ExpectedCommandError
from . import boorusources
from .CONSTANTS import FILTERS, NSFW_FILTERS, BOARDS, HEADERS, NSFW_BOARDS, tags_to_board
cache = SimpleMemoryCache()
log = logging.getLogger("BooruCore")
log.setLevel(logging.DEBUG)
class BooruCore:
async def generic_booru(self, ctx, tag):
tag = await self.filter_tags(ctx, tag)
# If it returns nothing, something is wrong
if tag is None:
return
log.debug(tag)
boards = tags_to_board(tag)
if not ctx.message.channel.is_nsfw():
import os
import asyncio
from aiocache import SimpleMemoryCache
from aiohttp import web, client_exceptions, ClientSession
BASE_URL = "https://demo.calendar42.com/api/v2"
TOKEN = os.environ.get('CALENDAR42_TOKEN')
# NOTE: use redis in production
cache = SimpleMemoryCache(timeout=260) # 4.2 min
async def fetch(url, session):
"""
Returns JSON content of the page.
"""
cached = await cache.get(url)
if cached:
return cached
headers = {
'Content-type': 'application/json',
'Authorization': 'Token {token}'.format(token=TOKEN),
}
async with session.get(url, headers=headers) as response:
data = await response.json()
if response.status == 200:
await cache.set(url, data)
else:
def __init__(self, db, feed_url: str = TELAVIV_FEED_URL):
self.feed_url: str = feed_url
self.db = db
self.cache = SimpleMemoryCache()
async def reuse_data():
cache = SimpleMemoryCache(
serializer=JsonSerializer()) # Not ideal to define here
data = await cache.get("my_custom_key"
) # Note the key is defined in `cached` decorator
return data
from aiocache import SimpleMemoryCache
'''
https://aiocache.readthedocs.io/en/latest/
pip install aiocache
pip install aiocache[memcached]
'''
ch = SimpleMemoryCache()
if __name__ == '__main__':
ch.multi_set([[1, {1: "1"}], [2, {2: "2"}]])
d = ch.multi_get([1, 2, 3])
print(d)
from aiocache import SimpleMemoryCache
from aiocache.serializers import JsonSerializer
from aiohttp import web
from aiohttp_apispec import docs, response_schema, use_kwargs
from marshmallow import ValidationError
from {{cookiecutter.project_slug}}.entities.requests import RequestPostDummy
from {{cookiecutter.project_slug}}.entities.responses import ResponseGetDummyData, ResponseGetDummy, \
ResponseInternalError
from {{cookiecutter.project_slug}}.services.dummy import get_dummy, post_dummy
from {{cookiecutter.project_slug}}.log_manager import log_manager
LOGGER = log_manager.getLogger(module_name=__name__)
cache = SimpleMemoryCache(serializer=JsonSerializer())
class DummyHandler(web.View):
@docs(tags=['dummy'],
summary='Get dummy',
description='''Dummy resource''')
@response_schema(ResponseGetDummyData.Schema(), 200, description="Single dummy", required=True)
@response_schema(ResponseInternalError.Schema(), 400, description="Error description", required=True)
async def get(self):
dummy = await get_dummy()
try:
payload = dummy.make_dump()
except ValidationError as err:
return web.json_response({"error": err.messages}, status=400)
return web.json_response({"data": payload})
# dumps returns (data, errors), we just want to save data
return super().dumps(*args, **kwargs).data
def loads(self, *args, **kwargs):
# dumps returns (data, errors), we just want to return data
return super().loads(*args, **kwargs).data
@post_load
def build_my_type(self, data):
return RandomModel(**data)
class Meta:
strict = True
cache = SimpleMemoryCache(serializer=MarshmallowSerializer(), namespace="main")
async def serializer():
model = RandomModel()
await cache.set("key", model)
result = await cache.get("key")
assert result.int_type == model.int_type
assert result.str_type == model.str_type
assert result.dict_type == model.dict_type
assert result.list_type == model.list_type
def test_serializer():
async def view_search_result(request):
cache = SimpleMemoryCache(serializer=JsonSerializer())
response_dict = await cache.get("response_dict")
if not response_dict:
response_dict = {}
return response_dict
from datetime import datetime
from time import mktime
import aiohttp
from aiocache import cached, SimpleMemoryCache
from aiocache.serializers import PickleSerializer
from aiohttp import web
from lru_plugin import LRUPlugin
steps_cache = SimpleMemoryCache(serializer=PickleSerializer(),
plugins=[LRUPlugin(max_keys=1000)])
class HTTPForbidden(Exception):
pass
async def get_steps(lesson_id, lsteps, update_date):
"""Works with the cache, where steps are stored.
Return True if step is theoretical and False if not. If access if forbidden, raise HTTPForbidden error.
:param lesson_id: str lesson id
:param lsteps: list of lesson's steps
:param update_date: int timestamp when lesson was updated
"""
result = []
if await steps_cache.exists(lesson_id):
cached_steps = await steps_cache.get(lesson_id)
# If data wasn't updated before, then return from cache
if cached_steps[0] >= update_date:
