Ejemplo n.º 1
0
    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")
Ejemplo n.º 2
0
    def getMetadata(self, objectId=None, **filters):
        """ Request metadata about a text or a collection

        :param textId: Object Identifier to filter on
        :type textId: str
        :param filters: Kwargs parameters.
        :type filters: dict
        :return: Collection
        """
        if objectId is not None:
            filters["urn"] = objectId

        ti = TextInventory()
        ti.parse(self.endpoint.getCapabilities(**filters))
        if objectId:
            return [x for x in [ti] + ti.descendants if x.id == objectId][0]
        return ti
Ejemplo n.º 3
0
    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
        """
        if objectId is None:
            return self.inventory
        texts, _, _ = self.__getTextMetadata__(urn=objectId)
        inventory = TextInventory()
        # For each text we found using the filter
        for text in texts:
            tg_urn = str(text.parents[1].urn)
            wk_urn = str(text.parents[0].urn)
            txt_urn = str(text.urn)
            # If we need to generate a textgroup object
            if tg_urn not in inventory.textgroups:
                inventory.textgroups[tg_urn] = copy(text.parents[1])
                inventory.textgroups[tg_urn].works = OrderedDict()
            # If we need to generate a work object
            if wk_urn not in inventory.textgroups[tg_urn].works:
                inventory.textgroups[tg_urn].works[wk_urn] = copy(text.parents[0])
                inventory.textgroups[tg_urn].works[wk_urn].parents = tuple(
                    [inventory, inventory.textgroups[tg_urn]]
                )
                inventory.textgroups[tg_urn].works[wk_urn].texts = OrderedDict()
            __text = copy(text)
            inventory.textgroups[tg_urn].works[wk_urn].texts[txt_urn] = __text
            __text.parents = tuple([
                inventory,
                inventory.textgroups[tg_urn],
                inventory.textgroups[tg_urn].works[wk_urn]
            ])
        return inventory[objectId]
Ejemplo n.º 4
0
            self.getPassage_Capabilities = RequestPatchChained(
                [self.getCapabilities, self.getPassage])

        with open("tests/test_data/getpassageplus.xml", "r") as f:
            self.getPassagePlus = RequestPatch(f)

        with open("tests/test_data/getprevnext.xml", "r") as f:
            self.getPrevNext = RequestPatch(f)
            self.getPassage_Route = RequestPatchChained(
                [self.getCapabilities, self.getPassage, self.getPrevNext])

        self.nemo = Nemo(resolver=NemoResource.endpoint, app=Flask(__name__))


tic = TextInventoryCollection()
latin = TextInventory("urn:perseus:latinLit")
latin.parent = tic
latin.set_label("Classical Latin", "eng")
farsi = TextInventory("urn:perseus:farsiLit")
farsi.parent = tic
farsi.set_label("Farsi", "eng")
gc = TextInventory("urn:perseus:greekLit")
gc.parent = tic
gc.set_label("Ancient Greek", "eng")
gc.set_label("Grec Ancien", "fre")

dispatcher = CollectionDispatcher(tic)


@dispatcher.inventory("urn:perseus:latinLit")
def dispatchLatinLit(collection, path=None, **kwargs):