def __init__(self, resource, inventories=None, cache=None, name=None, logger=None, auto_parse=True): """ Initiate the XMLResolver """ super(XMLFolderResolver, self).__init__(resource=resource) if not isinstance(cache, BaseCache): cache = BaseCache() self.__inventories__ = inventories self.__parser__ = makeparser() self.__cache = cache self.name = name self.logger = logger if not logger: self.logger = logging.getLogger(name) if not name: self.name = "repository" self.TEXT_CLASS = XMLFolderResolver.TEXT_CLASS self.works = [] self.inventory_cache_key = _cache_key("Nautilus", "Inventory", "Resources", self.name) self.texts_metadata_cache_key = _cache_key("Nautilus", "Inventory", "TextsMetadata", self.name) self.texts_parsed_cache_key = _cache_key("Nautilus", "Inventory", "TextsParsed", self.name) __inventory__ = self.__cache.get(self.inventory_cache_key) __texts__ = self.__cache.get(self.texts_metadata_cache_key) if __inventory__ and __texts__: self.inventory, self.__texts__ = __inventory__, __texts__ elif auto_parse: self.parse(resource)
def __init__(self, resource, name=None, logger=None, cache=None, dispatcher=None): """ Initiate the XMLResolver """ if dispatcher is None: inventory_collection = TextInventoryCollection(identifier="defaultTic") ti = TextInventory("default") ti.parent = inventory_collection ti.set_label("Default collection", "eng") self.dispatcher = CollectionDispatcher(inventory_collection) else: self.dispatcher = dispatcher self.__inventory__ = None self.__texts__ = [] self.name = name self.logger = logger if not logger: self.logger = logging.getLogger(name) if not name: self.name = "repository" if cache is None: cache = NullCache() self.__cache__ = cache self.__resources__ = resource self.inventory_cache_key = _cache_key("Nautilus", self.name, "Inventory", "Resources") self.texts_parsed_cache_key = _cache_key("Nautilus", self.name, "Inventory", "TextsParsed")
def getTextualNode(self, textId, subreference=None, prevnext=False, metadata=False): """ Retrieve a text node from the API :param textId: PrototypeText Identifier :type textId: str :param subreference: Passage Reference :type subreference: str :param prevnext: Retrieve graph representing previous and next passage :type prevnext: boolean :param metadata: Retrieve metadata about the passage and the text :type metadata: boolean :return: Passage :rtype: Passage """ key = _cache_key("Nautilus", self.name, "Passage", textId, subreference) o = self.cache.get(key) if o is not None: return o text, text_metadata = self.__getText__(textId) if subreference is not None: subreference = Reference(subreference) passage = text.getTextualNode(subreference) passage.set_metadata_from_collection(text_metadata) self.cache.set(key, passage) return passage
def cache_to_text(self, urn): """ Get a text from Cache :param text: Text to be cached :return: Text object :rtype: Text """ return self.__cache.get(_cache_key(self.texts_parsed_cache_key, str(urn)))
def flush(self): """ Flush current resolver objects and cache """ self.inventory = TextInventory() for text in self.__texts__: self.__cache.delete(_cache_key(self.texts_parsed_cache_key, str(text.urn))) self.__texts__ = [] self.__cache.delete(self.inventory_cache_key) self.__cache.delete(self.texts_metadata_cache_key)
def read(self, identifier, path=None): """ Read a text object given an identifier and a path :param identifier: Identifier of the text :param path: Path of the text files :return: Text """ if self.CACHE_FULL_TEI is True: o = self.cache.get(_cache_key(self.texts_parsed_cache_key, identifier)) if o is not None: return o else: with open(path) as f: o = Text(urn=identifier, resource=self.xmlparse(f)) self.cache.set(_cache_key(self.texts_parsed_cache_key, identifier), o) else: with open(path) as f: o = Text(urn=identifier, resource=self.xmlparse(f)) return o
def xmlparse(self, file): """ Parse a XML file :param file: Opened File :return: Tree """ if self.CACHE_FULL_TEI is True: return self.get_or( _cache_key("Nautilus", self.name, "File", "Tree", file.name), super(NautilusCTSResolver, self).xmlparse, file ) return super(NautilusCTSResolver, self).xmlparse(file)
def getMetadata(self, objectId=None, **filters): """ Request metadata about a text or a collection :param objectId: Object Identifier to filter on :type objectId: str :param filters: Kwargs parameters. :type filters: dict :return: Collection """ return self.get_or( _cache_key("Nautilus", self.name, "GetMetadata", objectId), super(NautilusCTSResolver, self).getMetadata, objectId )
def getValidReff(self, level=1, reference=None): """ Cached method of the original object :param level: :param reference: Reference object :return: References """ __cachekey__ = _cache_key("Text_GetValidReff", level, str(self.urn), str(reference)) __cached__ = self.cache.get(__cachekey__) if __cached__: return __cached__ else: __cached__ = super(Text, self).getValidReff(level, reference) self.cache.set(__cachekey__, __cached__, timeout=Text.TIMEOUT["getValidReff"]) return __cached__
def getSiblings(self, textId, subreference): """ Retrieve the siblings of a textual node :param textId: PrototypeText Identifier :type textId: str :param subreference: Passage Reference :type subreference: str :return: Tuple of references :rtype: (str, str) """ key = _cache_key("Nautilus", self.name, "Siblings", textId, subreference) o = self.cache.get(key) if o is not None: return o passage = self.getTextualNode(textId, subreference, prevnext=True) siblings = passage.siblingsId self.cache.set(key, siblings) return siblings
def text_to_cache(self, text): """ Cache a text :param text: Text to be cached """ self.__cache.set(_cache_key(self.texts_parsed_cache_key, str(text.urn)), text)
def __cache_key_reffs__(self, textId, level, subreference): return _cache_key("Nautilus", self.name, "getReffs", textId, level, subreference)