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)
