def set_caching(self, caching): if caching is None: caching = self.default_cache if caching is True: caching = MaxCache() elif caching is False: caching = NoCache() elif type(caching) is int: caching = WeakLRUCache(caching) if isinstance(caching, Cache): self.cache = caching.transfer(self.cache)
def __init__( self, auth_token, url="http://content-api.p2p.tribuneinteractive.com", debug=False, cache=NoCache(), image_services_url=None, product_affiliate_code='lanews', source_code='latimes', webapp_name='tRibbit', state_filter='working,live,pending,copyready', preserve_embedded_tags=True ): self.config = { 'P2P_API_ROOT': url, 'P2P_API_KEY': auth_token, 'IMAGE_SERVICES_URL': image_services_url, } self.cache = cache self.debug = debug self.product_affiliate_code = product_affiliate_code self.source_code = source_code self.webapp_name = webapp_name self.state_filter = state_filter self.preserve_embedded_tags = preserve_embedded_tags self.default_filter = { 'product_affiliate': self.product_affiliate_code, 'state': self.state_filter } self.default_content_item_query = { 'include': [ 'web_url', 'section', 'related_items', 'content_topics', 'embedded_items' ], 'filter': self.default_filter } self.content_item_defaults = { "content_item_type_code": "blurb", "product_affiliate_code": self.product_affiliate_code, "source_code": self.source_code, "content_item_state_code": "live", } self.s = requests.Session() self.s.mount('https://', TribAdapter())
def __init__(self, name, content_class): """ Parameters ---------- name : str the name of the store content_class : class the base class of the content, must be subclassed from `StorableMixin` """ super(ObjectStore, self).__init__() self._storage = None self.content_class = content_class self.cache = NoCache() self._free = set() self._cached_all = False self._created = False self._document = None self.name = name self.attribute_list = {} self.cv = {} # This will not be stored since its information is contained in the # dimension names self._dimension_name_store = None self.variables = dict() self.units = dict() self.index = None self.proxy_index = WeakValueDictionary() if self.content_class is not None \ and not issubclass(self.content_class, StorableMixin): raise ValueError( 'Content class "%s" must be subclassed from StorableMixin.' % self.content_class.__name__)
def __init__(self, url, auth_token, debug=False, cache=NoCache(), image_services_url=None, product_affiliate_code='chinews', source_code='chicagotribune', webapp_name='tRibbit'): self.config = { 'P2P_API_ROOT': url, 'P2P_API_KEY': auth_token, 'IMAGE_SERVICES_URL': image_services_url, } self.cache = cache self.debug = debug self.product_affiliate_code = product_affiliate_code self.source_code = source_code self.webapp_name = webapp_name self.default_filter = { 'product_affiliate': self.product_affiliate_code, 'state': 'live' } self.default_content_item_query = { 'include': [ 'web_url', 'section', 'related_items', 'content_topics', 'embedded_items' ], 'filter': self.default_filter } self.content_item_defaults = { "content_item_type_code": "blurb", "product_affiliate_code": self.product_affiliate_code, "source_code": self.source_code, "content_item_state_code": "live", } self.s = requests.Session() self.s.mount('https://', TribAdapter())
def set_caching(self, caching): """ Set the caching mode for this store Parameters ---------- caching : :class:`mongodb.Cache` """ if caching is None: caching = self.default_cache if caching is True: caching = MaxCache() elif caching is False: caching = NoCache() elif type(caching) is int: caching = WeakLRUCache(caching) if isinstance(caching, Cache): self.cache = caching.transfer(self.cache)
def __init__(self, content_class, json=True, caching=None, nestable=False, has_name=False): """ Parameters ---------- storage content_class json dimension_units caching : dict-like or bool or int or None this is the dict used for caching. `True` means to use a python built-in dict which unlimited caching. Be careful. `False` means no caching at all. If a dict-like object is passed, it will be used. An integer `n` means to use LRU Caching with maximal n elements and is equal to `cache=LRUCache(n)` Default (None) is equivalent to `cache=ObjectStore.default_cache` nestable : bool if true this marks the content_class to be saved as nested dict objects and not a pointing to saved objects. So the saved complex object is only stored once and not split into several objects that are referenced by each other in a tree-like fashion Notes ----- Usually you want caching, but limited. Recommended is to use an LRUCache with a reasonable number that depends on the typical number of objects to cache and their size Attributes ---------- storage : Storage the reference the Storage object where all data is stored content_class : class a reference to the class type to be stored using this Storage has_name : bool if `True` objects can also be loaded by a string name json : string if already computed a JSON Serialized string of the object simplifier : util.StorableObjectJSON an instance of a JSON Serializer identifier : str name of the netCDF variable that contains the string to be identified by. So far this is `name` cache : dict-like (int or str : object) a dictionary that holds references to all stored elements by index or string for named objects. This is only used for cached access if caching is not `False` Notes ----- The class that takes care of storing data in a file is called a Storage, so the netCDF subclassed Storage is a storage. The classes that know how to load and save an object from the storage are called stores, like ObjectStore, SampleStore, etc... """ self._storage = None self.content_class = content_class self.prefix = None self.cache = NoCache() self.has_name = has_name self.json = json self._free = set() self._cached_all = False self._names_loaded = False self.nestable = nestable self.name_idx = dict() self.variables = dict() self.vars = dict() self.units = dict() self.index = weakref.WeakKeyDictionary()