def __init__(self, app, config, *args): self.caches = [ flask_caching.Cache(app, config={ "CACHE_TYPE": 'redis', "CACHE_REDIS_URL": url }) for url in app.config['redis_urls'] ]
def __init__(self, app: Dash) -> None: cache_dir = ( WEBVIZ_INSTANCE_INFO.storage_folder / f"SurfaceServer_filecache_{uuid4()}" ) LOGGER.debug(f"Setting up file cache in: {cache_dir}") self._image_cache = flask_caching.Cache( config={ "CACHE_TYPE": "FileSystemCache", "CACHE_DIR": cache_dir, "CACHE_DEFAULT_TIMEOUT": 0, } ) self._image_cache.init_app(app.server) self._setup_url_rule(app)
def __init__(self, app: dash.Dash): app.server.logger.info(f"REDIS: {config.redis_host} {config.redis_key}") self.cache: flask_caching.Cache = flask_caching.Cache(app.server, config=dict( CACHE_TYPE="redis", CACHE_REDIS_HOST=config.redis_host, CACHE_REDIS_PASSWORD="******", CACHE_REDIS_PORT=6380, CACHE_REDIS_DB=0, CACHE_OPTIONS={"ssl": True} )) self.r: redis.Redis = self.cache.cache._read_clients # NoQA self.key_prefix = self.cache.cache.key_prefix self.environment = "prod" if config.is_production else "dev" self.app = app
import flask_caching CACHE = flask_caching.Cache(config={"CACHE_TYPE": "simple"}) CACHE.TIMEOUT = 3600
import flask_caching from server import app, cache_config cache = flask_caching.Cache() def main(): cache.init_app(app, config=cache_config) with app.app_context(): cache.clear() if __name__ == '__main__': main()
'color': '#1f77b4', 'width': 0 }), ] logging.basicConfig(level=logging.INFO, format="%(levelname)s:%(name)s:%(threadName)s:%(message)s") app = dash.Dash(__name__) app.css.append_css( {'external_url': 'https://codepen.io/chriddyp/pen/bWLwgP.css'}) # app.css.append_css({'external_url': 'https://codepen.io/chriddyp/pen/brPBPO.css'}) # app.css.append_css({'external_url': '/static/stylesheet.css'}) cache = flask_caching.Cache(app.server, config={ 'CACHE_TYPE': 'filesystem', 'CACHE_DIR': 'cache' }) def si_format(num): """ Convert num to a string with nice SI prefix formatting""" if num == 0: return u"0.0" mag = math.floor(math.log10(abs(num))) if mag >= -3 and mag <= 3: thous = 0 else: thous = int(math.floor(mag / 3)) letter = u' kMGTPE'[ thous] if thous > 0 else u' mμnpfa'[-thous] if thous < 0 else u'' return u"{:,.3f}{}".format(num / (1000.**thous), letter)
def cache(client): return fsc.Cache(client)
# from boomtrain.config import load_flask import main # import boomtrain.flask.service # app = boomtrain.flask.service.APIService(__name__) app = flask.Flask() # CONFIG = load_flask() DB_URL = os.env cache_config = { 'CACHE_TYPE': 'filesystem', 'CACHE_DIR': '/var/cache/flask', 'CACHE_DEFAULT_TIMEOUT': 900, 'CACHE_THRESHOLD': 999 } cache = flask_caching.Cache(app, config=cache_config) def debug_mode(): """Debug mode callable to disable cache in dev""" return app.debug def full_cache_key(): """Cache key callable that includes GET parameters.""" return flask.request.full_path @app.route('/') @cache.cached(unless=debug_mode) def index():
import time import urllib import querymanager import woeplanet.utils.uri as uri dotenv.load_dotenv(dotenv.find_dotenv()) app = flask.Flask(__name__) cache = flask_caching.Cache( config={ 'CACHE_TYPE': 'filesystem', 'CACHE_DEFAULT_TIMEOUT': 5, 'CACHE_IGNORE_ERRORS': False, 'CACHE_DIR': os.environ.get('WOE_CACHE_DIR'), 'CACHE_THRESHOLD': 500, 'CACHE_OPTIONS': { 'mode': int(os.environ.get('WOE_CACHE_MASK')) } }) cache.init_app(app) @app.template_filter() def commafy(value): return '{:,}'.format(value) @app.template_filter() def anyfy(value):
def __init__(self, app, config=None, **kwargs): super(FlaskCacheBackend, self).__init__(**kwargs) self.cache = flask_caching.Cache(app, config=config)
import flask_caching cache = flask_caching.Cache(config={ "CACHE_TYPE": "simple", "CACHE_DEFAULT_TIMEOUT": 300 }) cached = cache.cached delete = cache.delete delete_memoized = cache.delete_memoized memoize = cache.memoize
import pymongo import hdfs import io from datetime import datetime hdfs_url = "http://localhost:50070" db_url = "mongodb://localhost:27017" db_name = "db" hdfs_client = hdfs.InsecureClient(hdfs_url, user='******') db_client = pymongo.MongoClient(db_url) db = db_client[db_name] app = flask.Flask(__name__) cache = flask_caching.Cache(app, config={'CACHE_TYPE': 'redis'}) @cache.memoize(timeout=60) def retrieve_user(uid): user = db["user"].find_one({"uid": str(uid)}) if user is not None: del user["_id"] return user @cache.memoize(timeout=60) def retrieve_article(aid): article = db["article"].find_one({"aid": str(aid)}) if article is not None: del article["_id"]
#pylint: skip-file """dnstwister web app. This is the pattern from http://flask.pocoo.org/docs/0.11/patterns/packages/ which generates circular imports hence the comment at the top to just ignore this file. """ import flask import flask_caching import logging # Set up app/cache/db/emailer/gateway here app = flask.Flask(__name__) cache = flask_caching.Cache(app, config={'CACHE_TYPE': 'simple'}) # Logging app.logger.setLevel(logging.INFO) # Blueprints import api app.register_blueprint(api.app, url_prefix='/api') # Import modules using dnstwister.app/cache here. import tools import tools.template import views.www.analyse import views.www.index import views.www.search # Filters app.jinja_env.filters['domain_renderer'] = tools.template.domain_renderer
import pandas as pd from dash.dependencies import Input, Output import flask_caching # read csv file of hotel booking data # create dash app external_stylesheets = [ "https://cdn.jsdelivr.net/npm/[email protected]/css/bulma.min.css" ] app = dash.Dash(__name__, external_stylesheets=external_stylesheets) server = app.server # cache app cache = flask_caching.Cache(server, config={ "CACHE_TYPE": "filesystem", "CACHE_DIR": "cache-directory" }) TIMEOUT = 60 # pull data @cache.memoize(timeout=TIMEOUT) def hotel_data(): return pd.read_csv( "https://raw.githubusercontent.com/mfarris/hotel_data/master/hotel_bookings.csv" ) # base config
def cache(app): return fsc.Cache(app)
import flask import flask_caching from google.appengine.api import app_identity from google.appengine.api import images from google.appengine.api import wrap_wsgi_app from google.cloud import storage IMAGE_EXTENSIONS = ('.jpg', '.gif', '.png') app = flask.Flask(__name__) # The wrap_wsgi_app function sets up the request environ and stuff that the # legacy App Engine APIs expect. app.wsgi_app = wrap_wsgi_app(app.wsgi_app) # flask_caching's memcached backend automatically uses the legacy memcache API. cache = flask_caching.Cache(config={'CACHE_TYPE': 'MemcachedCache'}) cache.init_app(app) @functools.cache def get_bucket_name(): # For a GCP project `foo`, the default bucket is `foo.appspot.com` return app_identity.get_default_gcs_bucket_name() def get_uploaded_file(request, form_field='file'): """The uploaded file object and a random destination path in storage.""" file = request.files[form_field] ext = pathlib.Path(file.filename).suffix if ext not in IMAGE_EXTENSIONS:
import logging import repo logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) ch = logging.StreamHandler() ch.setLevel(logging.DEBUG) formatter = logging.Formatter( "%(asctime)s %(name)s %(levelname)s: %(message)s") ch.setFormatter(formatter) logger.addHandler(ch) app = flask.Flask(__name__) cache = flask_caching.Cache(app, config={"CACHE_TYPE": "simple"}) @cache.cached(timeout=600, key_prefix="get_git_repos") def get_git_repos(): return [repo["node"] for repo in repo.get_git_repos(max_repos=20)] @app.route("/") def index(): try: repos = get_git_repos() except Exception as e: # Yuck. Ugly hack for error handling. logger.warning("Failed to retrieve repos: {e}".format(e=e)) repos = [{
import datetime import flask_caching as fcache import json import os import MapSummary from database import DatabaseConnection import valve.source.a2s from valve.source import NoResponseError app = flask.Flask("open-leaderboard") if os.path.isfile("config.py"): app.config.from_object("config") cache = fcache.Cache(app, config={'CACHE_TYPE': 'simple'}) cache.init_app(app) SEGMENT = 100 SERVERS = list() def prettifyMinMaxY(computedMin, computedMax): if computedMax > 0 and computedMin > 0: return (0, 4000) else: return (computedMin - 100, 4000) @app.route("/players-online") def playersOnline():