Exemplo n.º 1
0
    def __getText__(self, urn):
        """ Returns a CtsTextMetadata object
        :param urn: URN of a text to retrieve
        :type urn: str, URN
        :return: Textual resource and metadata
        :rtype: (CapitainsCtsText, InventoryText)
        """
        if not isinstance(urn, URN):
            urn = URN(urn)
        if len(urn) != 5:
            if len(urn) == 4:
                urn, reference = urn.upTo(URN.WORK), str(urn.reference)
                urn = [
                    t.id
                    for t in self.texts
                    if t.id.startswith(str(urn)) and isinstance(t, XmlCtsEditionMetadata)
                ]
                if len(urn) > 0:
                    urn = URN(urn[0])
                else:
                    raise UnknownObjectError
            else:
                raise InvalidURN

        text = self.inventory[str(urn)]

        if os.path.isfile(text.path):
            with io.open(text.path) as __xml__:
                resource = self.TEXT_CLASS(urn=urn, resource=self.xmlparse(__xml__))
        else:
            resource = None
            self.logger.warning('The file {} is mentioned in the metadata but does not exist'.format(text.path))

        return resource, text
Exemplo n.º 2
0
    def __urnitem__(self, key):
        urn = URN(key)

        if len(urn) <= 2:
            raise ValueError("Not valid urn")
        elif hasattr(self, "urn") and self.urn == urn:
            return self
        else:
            if hasattr(self, "urn"):
                i = len(self.urn)
            else:
                i = 2

            if isinstance(self, TextInventory):
                children = self.textgroups
            elif isinstance(self, TextGroup):
                children = self.works
            elif isinstance(self, Work):
                children = self.texts

            order = ["", "", URN.TEXTGROUP, URN.WORK, URN.VERSION]
            while i <= len(urn) - 1:
                children = children[urn.upTo(order[i])]
                if not hasattr(children, "urn") or str(children.urn) != urn.upTo(order[i]):
                    error = "Unrecognized urn at " + [
                        "URN namespace", "CTS Namespace", "URN Textgroup", "URN Work", "URN Version"
                    ][i]
                    raise ValueError(error)
                i += 1
            return children
Exemplo n.º 3
0
    def __urnitem__(self, key):
        urn = URN(key)

        if len(urn) <= 2:
            raise ValueError("Not valid urn")
        elif hasattr(self, "urn") and self.urn == urn:
            return self
        else:
            if hasattr(self, "urn"):
                i = len(self.urn)
            else:
                i = 2

            if isinstance(self, TextInventory):
                children = self.textgroups
            elif isinstance(self, TextGroup):
                children = self.works
            elif isinstance(self, Work):
                children = self.texts

            order = ["", "", URN.TEXTGROUP, URN.WORK, URN.VERSION]
            while i <= len(urn) - 1:
                children = children[urn.upTo(order[i])]
                if not hasattr(children, "urn") or str(
                        children.urn) != urn.upTo(order[i]):
                    error = "Unrecognized urn at " + [
                        "URN namespace", "CTS Namespace", "URN Textgroup",
                        "URN Work", "URN Version"
                    ][i]
                    raise ValueError(error)
                i += 1
            return children
Exemplo n.º 4
0
    def urn(self, value):
        """ Set the urn

        :param value: URN to be saved
        :type value: URN, basestring, str
        :raises: *TypeError* when the value is not URN compatible

        .. note:: `Passage.URN = ...` will update automatically the id property if Passage is set

        """
        a = self._URN

        if isinstance(value, basestring):
            value = URN(value)
        elif not isinstance(value, URN):
            raise TypeError()

        if str(a) != str(value):
            self._URN = value

            if value.reference and self.__reference != value.reference:
                self.__reference = value.reference
            elif not value.reference and self.__reference and len(
                    self.__reference):
                self._URN = URN("{}:{}".format(str(value),
                                               str(self.__reference)))
Exemplo n.º 5
0
 def test_equality(self):
     a = URN("urn:cts:greekLit:tlg0012.tlg001.mth-01:[email protected]@the[2]")
     b = URN("urn:cts:greekLit:tlg0012.tlg001.mth-01:[email protected]@the[2]")
     c = URN("urn:cts:greekLit:tlg0012.tlg001.mth-01:[email protected]@the[3]")
     d = "urn:cts:greekLit:tlg0012.tlg001.mth-01:[email protected]@the[2]"
     self.assertEqual(a, b)
     self.assertNotEqual(a, c)
     self.assertNotEqual(a, d)
Exemplo n.º 6
0
 def test_from_work_emptiness(self):
     a = URN("urn:cts:greekLit:textgroup.work")
     self.assertEqual(str(a), "urn:cts:greekLit:textgroup.work")
     self.assertEqual(a.upTo(URN.COMPLETE), "urn:cts:greekLit:textgroup.work")
     self.assertEqual(a.upTo(URN.NAMESPACE), "urn:cts:greekLit")
     self.assertEqual(a.upTo(URN.TEXTGROUP), "urn:cts:greekLit:textgroup")
     self.assertEqual(a.upTo(URN.WORK), "urn:cts:greekLit:textgroup.work")
     self.assertIsNone(a.version)
     self.assertIsNone(a.reference)
Exemplo n.º 7
0
 def test_full_emptiness(self):
     a = URN("urn:cts:greekLit")
     self.assertEqual(str(a), "urn:cts:greekLit")
     self.assertEqual(a.upTo(URN.COMPLETE), "urn:cts:greekLit")
     self.assertEqual(a.upTo(URN.NAMESPACE), "urn:cts:greekLit")
     self.assertIsNone(a.textgroup)
     self.assertIsNone(a.work)
     self.assertIsNone(a.version)
     self.assertIsNone(a.reference)
Exemplo n.º 8
0
 def test_from_textgroup_emptiness(self):
     a = URN("urn:cts:greekLit:textgroup")
     self.assertEqual(a.upTo(URN.COMPLETE), "urn:cts:greekLit:textgroup")
     self.assertEqual(str(a), "urn:cts:greekLit:textgroup")
     self.assertEqual(a.upTo(URN.NAMESPACE), "urn:cts:greekLit")
     self.assertEqual(a.upTo(URN.TEXTGROUP), "urn:cts:greekLit:textgroup")
     self.assertIsNone(a.work)
     self.assertIsNone(a.version)
     self.assertIsNone(a.reference)
Exemplo n.º 9
0
 def test_from_text_emptiness(self):
     a = URN("urn:cts:greekLit:textgroup.work.text")
     self.assertEqual(str(a), "urn:cts:greekLit:textgroup.work.text")
     self.assertEqual(a.upTo(URN.COMPLETE), "urn:cts:greekLit:textgroup.work.text")
     self.assertEqual(a.upTo(URN.NAMESPACE), "urn:cts:greekLit")
     self.assertEqual(a.upTo(URN.TEXTGROUP), "urn:cts:greekLit:textgroup")
     self.assertEqual(a.upTo(URN.WORK), "urn:cts:greekLit:textgroup.work")
     self.assertEqual(a.upTo(URN.VERSION), "urn:cts:greekLit:textgroup.work.text")
     self.assertIsNone(a.reference)
Exemplo n.º 10
0
 def test_properties(self):
     a = URN("urn:cts:greekLit:tlg0012.tlg001.mth-01:[email protected]@the[2]")
     self.assertEqual(a.urn_namespace, "cts")
     a.urn_namespace = "dts"
     self.assertEqual(a.urn_namespace, "dts")
     self.assertEqual(a.namespace, "greekLit")
     self.assertEqual(a.textgroup, "tlg0012")
     self.assertEqual(a.work, "tlg001")
     self.assertEqual(a.version, "mth-01")
     self.assertEqual(a.reference, Reference("[email protected]@the[2]"))
Exemplo n.º 11
0
 def test_properties(self):
     a = URN("urn:cts:greekLit:tlg0012.tlg001.mth-01:[email protected]@the[2]")
     self.assertEqual(a.urn_namespace, "cts")
     a.urn_namespace = "dts"
     self.assertEqual(a.urn_namespace, "dts")
     self.assertEqual(a.namespace, "greekLit")
     self.assertEqual(a.textgroup, "tlg0012")
     self.assertEqual(a.work, "tlg001")
     self.assertEqual(a.version, "mth-01")
     self.assertEqual(a.reference, Reference("[email protected]@the[2]"))
Exemplo n.º 12
0
 def test_resource_parser(self):
     """ Test that the initiation finds correctly the resources """
     Repository = NautilusCTSResolver(["./tests/testing_data/farsiLit"])
     self.assertEqual(Repository.inventory["urn:cts:farsiLit:hafez"].urn,
                      URN("urn:cts:farsiLit:hafez"), "Hafez is found")
     self.assertEqual(
         len(Repository.inventory["urn:cts:farsiLit:hafez"].works), 1,
         "Hafez has one child")
     self.assertEqual(
         Repository.inventory["urn:cts:farsiLit:hafez.divan"].urn,
         URN("urn:cts:farsiLit:hafez.divan"), "Divan is found")
     self.assertEqual(
         len(Repository.inventory["urn:cts:farsiLit:hafez.divan"].texts), 3,
         "Divan has 3 children")
Exemplo n.º 13
0
    def __init__(self,
                 resource=None,
                 urn=None,
                 parents=None,
                 subtype="Edition"):
        self.resource = None
        self.citation = None
        self.lang = None
        self.urn = None
        self.docname = None
        self.parents = list()
        self.subtype = subtype
        self.validate = None
        self.metadata = Metadata(
            keys=["label", "description", "namespaceMapping"])

        if urn is not None:
            self.urn = URN(urn)

        if parents is not None:
            self.parents = parents
            self.lang = self.parents[0].lang

        if resource is not None:
            self.setResource(resource)
Exemplo n.º 14
0
    def test_getpassage_variabletypes(self, requests):
        text = CtsText("urn:cts:latinLit:phi1294.phi002.perseus-lat2",
                       self.endpoint,
                       citation=self.citation)
        requests.return_value.text = GET_PASSAGE

        # Test with -1
        _ = text.getTextualNode(subreference=Reference("1.1"))
        requests.assert_called_with(
            "http://services.perseids.org/remote/cts",
            params={
                "request": "GetPassage",
                "urn": "urn:cts:latinLit:phi1294.phi002.perseus-lat2:1.1"
            })
        # Test with -1
        _ = text.getTextualNode(subreference=URN(
            "urn:cts:latinLit:phi1294.phi002.perseus-lat2:1.2"))
        requests.assert_called_with(
            "http://services.perseids.org/remote/cts",
            params={
                "request": "GetPassage",
                "urn": "urn:cts:latinLit:phi1294.phi002.perseus-lat2:1.2"
            })
        # Test with -1
        _ = text.getTextualNode(subreference=["1", "1", "1"])
        requests.assert_called_with(
            "http://services.perseids.org/remote/cts",
            params={
                "request": "GetPassage",
                "urn": "urn:cts:latinLit:phi1294.phi002.perseus-lat2:1.1.1"
            })
Exemplo n.º 15
0
    def __init__(self, urn="", parent=None):
        super(CtsTextgroupMetadata, self).__init__(identifier=str(urn))
        self.__urn__ = URN(urn)
        self.__children__ = defaultdict(CtsWorkMetadata)

        if parent is not None:
            self.parent = parent
Exemplo n.º 16
0
 def test_upTo(self):
     a = URN("urn:cts:greekLit:tlg0012.tlg001.mth-01:[email protected]@the[2]")
     self.assertEqual(a.upTo(URN.COMPLETE), "urn:cts:greekLit:tlg0012.tlg001.mth-01:[email protected]@the[2]")
     self.assertEqual(a.upTo(URN.NAMESPACE), "urn:cts:greekLit")
     self.assertEqual(a.upTo(URN.TEXTGROUP), "urn:cts:greekLit:tlg0012")
     self.assertEqual(a.upTo(URN.WORK), "urn:cts:greekLit:tlg0012.tlg001")
     self.assertEqual(a.upTo(URN.VERSION), "urn:cts:greekLit:tlg0012.tlg001.mth-01")
     self.assertEqual(a.upTo(URN.PASSAGE), "urn:cts:greekLit:tlg0012.tlg001.mth-01:[email protected]@the[2]")
     self.assertEqual(a.upTo(URN.PASSAGE_START), "urn:cts:greekLit:tlg0012.tlg001.mth-01:1.1@Achilles")
     self.assertEqual(a.upTo(URN.PASSAGE_END), "urn:cts:greekLit:tlg0012.tlg001.mth-01:1.10@the[2]")
Exemplo n.º 17
0
    def getTextualNode(self, subreference=None, simple=False):
        """ Finds a passage in the current text

        :param subreference: Identifier of the subreference / passages
        :type subreference: Union[list, CtsReference]
        :param simple: If set to true, retrieves nodes up to the given one, cleaning non required siblings.
        :type simple: boolean
        :rtype: CapitainsCtsPassage, ContextPassage
        :returns: Asked passage
        """
        if subreference is None:
            return self._getSimplePassage()

        if not isinstance(subreference, CtsReference):
            if isinstance(subreference, str):
                subreference = CtsReference(subreference)
            elif isinstance(subreference, list):
                subreference = CtsReference(".".join(subreference))

        if len(subreference.start) > self.citation.root.depth:
            raise CitationDepthError("URN is deeper than citation scheme")

        if simple is True:
            return self._getSimplePassage(subreference)

        if not subreference.is_range():
            start = end = subreference.start.list
        else:
            start, end = subreference.start.list, subreference.end.list

        citation_start = self.citation.root[len(start) - 1]
        citation_end = self.citation.root[len(end) - 1]

        start, end = citation_start.fill(passage=start), citation_end.fill(
            passage=end)
        start, end = normalizeXpath(start.split("/")[2:]), normalizeXpath(
            end.split("/")[2:])

        xml = self.textObject.xml

        if isinstance(xml, etree._Element):
            root = copyNode(xml)
        else:
            root = copyNode(xml.getroot())

        root = passageLoop(xml, root, start, end)

        if self.urn:
            urn = URN("{}:{}".format(self.urn, subreference))
        else:
            urn = None

        return CapitainsCtsPassage(urn=urn,
                                   resource=root,
                                   text=self,
                                   citation=citation_start,
                                   reference=subreference)
Exemplo n.º 18
0
 def test_missing_text_in_passage_emptiness(self):
     a = URN("urn:cts:greekLit:textgroup.work:1-2")
     self.assertEqual(str(a), "urn:cts:greekLit:textgroup.work:1-2")
     self.assertEqual(a.upTo(URN.COMPLETE), "urn:cts:greekLit:textgroup.work:1-2")
     self.assertEqual(a.upTo(URN.NAMESPACE), "urn:cts:greekLit")
     self.assertEqual(a.upTo(URN.TEXTGROUP), "urn:cts:greekLit:textgroup")
     self.assertEqual(a.upTo(URN.WORK), "urn:cts:greekLit:textgroup.work")
     self.assertEqual(a.upTo(URN.NO_PASSAGE), "urn:cts:greekLit:textgroup.work")
     self.assertEqual(a.upTo(URN.PASSAGE), "urn:cts:greekLit:textgroup.work:1-2")
     self.assertEqual(a.upTo(URN.PASSAGE_START), "urn:cts:greekLit:textgroup.work:1")
     self.assertEqual(a.upTo(URN.PASSAGE_END), "urn:cts:greekLit:textgroup.work:2")
     self.assertEqual(a.reference, Reference("1-2"))
     self.assertEqual(a.reference.start, Reference("1"))
     self.assertEqual(a.reference.end, Reference("2"))
     self.assertIsNone(a.version)
Exemplo n.º 19
0
    def test_init(self):
        a = PrototypeCtsNode(
            urn="urn:cts:latinLit:phi1294.phi002.perseus-lat2")
        self.assertEqual(a.id, "urn:cts:latinLit:phi1294.phi002.perseus-lat2")
        self.assertEqual(a.urn,
                         URN("urn:cts:latinLit:phi1294.phi002.perseus-lat2"))
        self.assertIsInstance(a.citation, Citation)

        a.resource = True
        self.assertEqual(a.resource, True)
Exemplo n.º 20
0
 def __getText__(self, urn):
     if not isinstance(urn, URN):
         urn = URN(urn)
     if len(urn) != 5:
         # this is different from MyCapytain in that we don't need to look
         # the first passage. let's always assume we get the right thing.
         raise InvalidURN()
     metadata = self.inventory[str(urn)]
     text = self.load_text(metadata.path)
     return text, metadata
Exemplo n.º 21
0
    def _r_GetFirstUrn(self, urn):
        """ Provisional route for GetFirstUrn request

        :param urn: URN to filter the resource
        :param inv: Inventory Identifier
        :return: GetFirstUrn response
        """
        urn = URN(urn)
        subreference = None
        textId = urn.upTo(URN.NO_PASSAGE)
        if urn.reference is not None:
            subreference = str(urn.reference)
        firstId = self.resolver.getTextualNode(
            textId=textId, subreference=subreference).firstId
        r = render_template("cts/GetFirstUrn.xml",
                            firstId=firstId,
                            full_urn=textId,
                            request_urn=str(urn))
        return r, 200, {"content-type": "application/xml"}
Exemplo n.º 22
0
    def _r_GetPrevNext(self, urn):
        """ Provisional route for GetPrevNext request

        :param urn: URN to filter the resource
        :param inv: Inventory Identifier
        :return: GetPrevNext response
        """
        urn = URN(urn)
        subreference = None
        textId = urn.upTo(URN.NO_PASSAGE)
        if urn.reference is not None:
            subreference = str(urn.reference)
        previous, nextious = self.resolver.getSiblings(
            textId=textId, subreference=subreference)
        r = render_template("cts/GetPrevNext.xml",
                            prev_urn=previous,
                            next_urn=nextious,
                            urn=textId,
                            request_urn=str(urn))
        return r, 200, {"content-type": "application/xml"}
 def test_deep_first(self):
     # Deep Annotations
     hits, annotations = self.query.getAnnotations(
         URN("urn:cts:latinLit:phi1294.phi002.perseus-lat2:1.pr.1-1.pr.3"))
     self.assertEqual(annotations[0], self.four,
                      "Deepest node should match as well")
     # Test with tuple
     hits, annotations = self.query.getAnnotations(
         ("urn:cts:latinLit:phi1294.phi002.perseus-lat2", "1.pr.1-1.pr.3"))
     self.assertEqual(annotations[0], self.four,
                      "Deepest node should match as well")
Exemplo n.º 24
0
    def getPrevNextUrn(self, reference):
        """ Get the previous URN of a reference of the text

        :param reference: Reference from which to find siblings
        :type reference: Union[Reference, str]
        :return: (Previous CapitainsCtsPassage Reference,Next CapitainsCtsPassage Reference)
        """
        _prev, _next = __SharedMethod__.prevnext(
            self.retriever.getPrevNextUrn(urn="{}:{}".format(
                str(URN(str(self.urn)).upTo(URN.NO_PASSAGE)), str(reference))))
        return _prev, _next
Exemplo n.º 25
0
    def _r_GetValidReff(self, urn, level):
        """ Provisional route for GetValidReff request

        :param urn: URN to filter the resource
        :param inv: Inventory Identifier
        :return: GetValidReff response
        """
        urn = URN(urn)
        subreference = None
        textId = urn.upTo(URN.NO_PASSAGE)
        if urn.reference is not None:
            subreference = str(urn.reference)
        reffs = self.resolver.getReffs(textId=textId,
                                       subreference=subreference,
                                       level=level)
        r = render_template("cts/GetValidReff.xml",
                            reffs=reffs,
                            urn=textId,
                            level=level,
                            request_urn=str(urn))
        return r, 200, {"content-type": "application/xml"}
Exemplo n.º 26
0
 def test_upTo(self):
     a = URN("urn:cts:greekLit:tlg0012.tlg001.mth-01:[email protected]@the[2]")
     self.assertEqual(a.upTo(URN.COMPLETE), "urn:cts:greekLit:tlg0012.tlg001.mth-01:[email protected]@the[2]")
     self.assertEqual(a.upTo(URN.NAMESPACE), "urn:cts:greekLit")
     self.assertEqual(a.upTo(URN.TEXTGROUP), "urn:cts:greekLit:tlg0012")
     self.assertEqual(a.upTo(URN.WORK), "urn:cts:greekLit:tlg0012.tlg001")
     self.assertEqual(a.upTo(URN.VERSION), "urn:cts:greekLit:tlg0012.tlg001.mth-01")
     self.assertEqual(a.upTo(URN.PASSAGE), "urn:cts:greekLit:tlg0012.tlg001.mth-01:[email protected]@the[2]")
     self.assertEqual(a.upTo(URN.PASSAGE_START), "urn:cts:greekLit:tlg0012.tlg001.mth-01:1.1@Achilles")
     self.assertEqual(a.upTo(URN.PASSAGE_END), "urn:cts:greekLit:tlg0012.tlg001.mth-01:1.10@the[2]")
Exemplo n.º 27
0
    def urn(self, value: Union[URN, str]):
        """ Set the urn

        :param value: URN to be saved
        :raises: *TypeError* when the value is not URN compatible

        """
        if isinstance(value, str):
            value = URN(value)
        elif not isinstance(value, URN):
            raise TypeError("New urn must be string or {} instead of {}".format(type(URN), type(value)))
        self._urn = value
Exemplo n.º 28
0
 def test_set(self):
     a = URN("urn:cts:latinLit:phi1294.phi002.perseus-lat2")
     a.reference = Reference("1.1")
     self.assertEqual(str(a), "urn:cts:latinLit:phi1294.phi002.perseus-lat2:1.1")
     a.reference = "2.2"
     self.assertEqual(str(a), "urn:cts:latinLit:phi1294.phi002.perseus-lat2:2.2")
     a.version = "perseus-eng2"
     self.assertEqual(str(a), "urn:cts:latinLit:phi1294.phi002.perseus-eng2:2.2")
     a.work = "phi001"
     self.assertEqual(str(a), "urn:cts:latinLit:phi1294.phi001.perseus-eng2:2.2")
     a.textgroup = "phi1293"
     self.assertEqual(str(a), "urn:cts:latinLit:phi1293.phi001.perseus-eng2:2.2")
     a.namespace = "greekLit"
     self.assertEqual(str(a), "urn:cts:greekLit:phi1293.phi001.perseus-eng2:2.2")
Exemplo n.º 29
0
    def _r_GetPassagePlus(self, urn):
        """ Provisional route for GetPassagePlus request

        :param urn: URN to filter the resource
        :param inv: Inventory Identifier
        :return: GetPassagePlus response
        """
        urn = URN(urn)
        subreference = None
        if len(urn) < 4:
            raise InvalidURN
        if urn.reference is not None:
            subreference = str(urn.reference)
        node = self.resolver.getTextualNode(textId=urn.upTo(URN.NO_PASSAGE),
                                            subreference=subreference)
        r = render_template(
            "cts/GetPassagePlus.xml",
            filters="urn={}".format(urn),
            request_urn=str(urn),
            full_urn=node.urn,
            prev_urn=node.prevId,
            next_urn=node.nextId,
            metadata={
                "groupname":
                [(literal.language, str(literal))
                 for literal in node.metadata.get(RDF_NAMESPACES.CTS.groupname)
                 ],
                "title":
                [(literal.language, str(literal))
                 for literal in node.metadata.get(RDF_NAMESPACES.CTS.title)],
                "description": [(literal.language, str(literal))
                                for literal in node.metadata.get(
                                    RDF_NAMESPACES.CTS.description)],
                "label":
                [(literal.language, str(literal))
                 for literal in node.metadata.get(RDF_NAMESPACES.CTS.label)]
            },
            citation=Markup(node.citation.export(Mimetypes.XML.CTS)),
            passage=Markup(node.export(Mimetypes.XML.TEI)))
        return r, 200, {"content-type": "application/xml"}
 def setUp(self):
     self.resolver = Resolver(LocalRetriever(path="./tests/test_data/"))
     self.one = (URN("urn:cts:latinLit:phi1294.phi002.perseus-lat2:6.1"),
                 "interface/treebanks/treebank1.xml", "dc:treebank")
     self.two = (URN("urn:cts:latinLit:phi1294.phi002.perseus-lat2:1.5"),
                 "interface/treebanks/treebank2.xml", "dc:treebank")
     self.three = (URN("urn:cts:latinLit:phi1294.phi002.perseus-lat2:6.1"),
                   "interface/images/N0060308_TIFF_145_145.tif", "dc:image")
     self.four = AnnotationResource(
         "interface/researchobject/researchobject.json",
         type_uri="dc:researchobject",
         target=URN("urn:cts:latinLit:phi1294.phi002.perseus-lat2:1.pr.1"),
         resolver=self.resolver)
     self.one_anno = AnnotationResource(self.one[1],
                                        type_uri=self.one[2],
                                        target=self.one[0],
                                        resolver=self.resolver)
     self.two_anno = AnnotationResource(self.two[1],
                                        type_uri=self.two[2],
                                        target=self.two[0],
                                        resolver=self.resolver)
     self.three_anno = AnnotationResource(self.three[1],
                                          type_uri=self.three[2],
                                          target=self.three[0],
                                          resolver=self.resolver)
     self.fourth_anno = AnnotationResource(
         self.three[1],
         type_uri=self.three[2],
         target=("urn:cts:latinLit:phi1294.phi002.perseus-lat2", "1-2"),
         resolver=self.resolver)
     self.app = Flask("app")
     logger = logging.getLogger('my-logger')
     logger.propagate = False
     self.nautilus = CtsCapitainsLocalResolver(
         ["tests/test_data/interface/latinLit"], logger=logger)
     self.nemo = Nemo(app=self.app, resolver=self.nautilus, base_url="")
     self.query = SimpleQuery(
         [self.one, self.two, self.three, self.four],  # List of annotations
         self.resolver)
     self.query.process(self.nemo)
Exemplo n.º 31
0
    def _r_GetPassage(self, urn):
        """ Provisional route for GetPassage request

        :param urn: URN to filter the resource
        :param inv: Inventory Identifier
        :return: GetPassage response
        """
        urn = URN(urn)
        subreference = None
        if len(urn) < 4:
            raise InvalidURN
        if urn.reference is not None:
            subreference = str(urn.reference)
        node = self.resolver.getTextualNode(textId=urn.upTo(URN.NO_PASSAGE),
                                            subreference=subreference)

        r = render_template("cts/GetPassage.xml",
                            filters="urn={}".format(urn),
                            request_urn=str(urn),
                            full_urn=node.urn,
                            passage=Markup(node.export(Mimetypes.XML.TEI)))
        return r, 200, {"content-type": "application/xml"}
Exemplo n.º 32
0
    def __getText__(self, urn):
        """ Returns a PrototypeText object
        :param urn: URN of a text to retrieve
        :type urn: str, URN
        :return: Textual resource and metadata
        :rtype: (Text, InventoryText)
        """
        if not isinstance(urn, URN):
            urn = URN(urn)
        if len(urn) != 5:
            if len(urn) == 4:
                urn, reference = urn.upTo(URN.WORK), str(urn.reference)
                urn = [
                    t.id
                    for t in self.texts
                    if t.id.startswith(str(urn)) and isinstance(t, Edition)
                ]
                if len(urn) > 0:
                    urn = URN(urn[0])
                else:
                    raise UnknownCollection
            else:
                raise InvalidURN

        try:
            text = self.inventory[str(urn)]
        except MyCapytain.errors.UnknownCollection as E:
            raise UnknownCollection(str(E))
        except Exception as E:
            raise E


        if os.path.isfile(text.path):
            resource = self.read(identifier=urn, path=text.path)
        else:
            resource = None
            raise UnknownCollection("File matching %s does not exist" % text.path)

        return resource, text
Exemplo n.º 33
0
 def test_init(self):
     """ Assert initation takes into account params
     """
     self.assertEqual(
         self.alias("urn:cts:latinLit:phi1294.phi002.perseus-lat2").objectId,
         "urn:cts:latinLit:phi1294.phi002.perseus-lat2",
         "String are taken as parameter"
     )
     self.assertEqual(
         self.alias(URN("urn:cts:latinLit:phi1294.phi002.perseus-lat2")).objectId,
         "urn:cts:latinLit:phi1294.phi002.perseus-lat2",
         "URN are taken as parameter"
     )
Exemplo n.º 34
0
    def urn(self, value):
        """ Set the urn

        :param value: URN to be saved
        :type value:  URN
        :raises: *TypeError* when the value is not URN compatible

        """
        if isinstance(value, text_type):
            value = URN(value)
        elif not isinstance(value, URN):
            raise TypeError()
        self.__urn__ = value
Exemplo n.º 35
0
 def test_missing_text_in_passage_emptiness(self):
     a = URN("urn:cts:greekLit:textgroup.work:1-2")
     self.assertEqual(str(a), "urn:cts:greekLit:textgroup.work:1-2")
     self.assertEqual(a.upTo(URN.COMPLETE), "urn:cts:greekLit:textgroup.work:1-2")
     self.assertEqual(a.upTo(URN.NAMESPACE), "urn:cts:greekLit")
     self.assertEqual(a.upTo(URN.TEXTGROUP), "urn:cts:greekLit:textgroup")
     self.assertEqual(a.upTo(URN.WORK), "urn:cts:greekLit:textgroup.work")
     self.assertEqual(a.upTo(URN.NO_PASSAGE), "urn:cts:greekLit:textgroup.work")
     self.assertEqual(a.upTo(URN.PASSAGE), "urn:cts:greekLit:textgroup.work:1-2")
     self.assertEqual(a.upTo(URN.PASSAGE_START), "urn:cts:greekLit:textgroup.work:1")
     self.assertEqual(a.upTo(URN.PASSAGE_END), "urn:cts:greekLit:textgroup.work:2")
     self.assertEqual(a.reference, Reference("1-2"))
     self.assertEqual(a.reference.start, Reference("1"))
     self.assertEqual(a.reference.end, Reference("2"))
     self.assertIsNone(a.version)
Exemplo n.º 36
0
 def test_no_end_text_emptiness(self):
     a = URN("urn:cts:greekLit:textgroup.work.text:1")
     self.assertEqual(str(a), "urn:cts:greekLit:textgroup.work.text:1")
     self.assertEqual(a.upTo(URN.COMPLETE), "urn:cts:greekLit:textgroup.work.text:1")
     self.assertEqual(a.upTo(URN.NAMESPACE), "urn:cts:greekLit")
     self.assertEqual(a.upTo(URN.TEXTGROUP), "urn:cts:greekLit:textgroup")
     self.assertEqual(a.upTo(URN.WORK), "urn:cts:greekLit:textgroup.work")
     self.assertEqual(a.upTo(URN.VERSION), "urn:cts:greekLit:textgroup.work.text")
     self.assertEqual(a.upTo(URN.PASSAGE), "urn:cts:greekLit:textgroup.work.text:1")
     self.assertEqual(a.upTo(URN.NO_PASSAGE), "urn:cts:greekLit:textgroup.work.text")
     self.assertEqual(a.reference, Reference("1"))
     self.assertIsNone(a.reference.end)
Exemplo n.º 37
0
 def test_set(self):
     a = URN("urn:cts:latinLit:phi1294.phi002.perseus-lat2")
     a.reference = Reference("1.1")
     self.assertEqual(str(a), "urn:cts:latinLit:phi1294.phi002.perseus-lat2:1.1")
     a.reference = "2.2"
     self.assertEqual(str(a), "urn:cts:latinLit:phi1294.phi002.perseus-lat2:2.2")
     a.version = "perseus-eng2"
     self.assertEqual(str(a), "urn:cts:latinLit:phi1294.phi002.perseus-eng2:2.2")
     a.work = "phi001"
     self.assertEqual(str(a), "urn:cts:latinLit:phi1294.phi001.perseus-eng2:2.2")
     a.textgroup = "phi1293"
     self.assertEqual(str(a), "urn:cts:latinLit:phi1293.phi001.perseus-eng2:2.2")
     a.namespace = "greekLit"
     self.assertEqual(str(a), "urn:cts:greekLit:phi1293.phi001.perseus-eng2:2.2")
Exemplo n.º 38
0
 def test_no_end_text_emptiness(self):
     a = URN("urn:cts:greekLit:textgroup.work.text:1")
     self.assertEqual(str(a), "urn:cts:greekLit:textgroup.work.text:1")
     self.assertEqual(a.upTo(URN.COMPLETE), "urn:cts:greekLit:textgroup.work.text:1")
     self.assertEqual(a.upTo(URN.NAMESPACE), "urn:cts:greekLit")
     self.assertEqual(a.upTo(URN.TEXTGROUP), "urn:cts:greekLit:textgroup")
     self.assertEqual(a.upTo(URN.WORK), "urn:cts:greekLit:textgroup.work")
     self.assertEqual(a.upTo(URN.VERSION), "urn:cts:greekLit:textgroup.work.text")
     self.assertEqual(a.upTo(URN.PASSAGE), "urn:cts:greekLit:textgroup.work.text:1")
     self.assertEqual(a.upTo(URN.NO_PASSAGE), "urn:cts:greekLit:textgroup.work.text")
     self.assertEqual(a.reference, Reference("1"))
     self.assertIsNone(a.reference.end)
Exemplo n.º 39
0
 def test_set(self):
     a = URN("urn:cts:greekLit:textgroup")
     a.textgroup = "tg"
     self.assertEqual(a.textgroup, "tg")
     self.assertEqual(str(a), "urn:cts:greekLit:tg")
     a.namespace = "ns"
     self.assertEqual(a.namespace, "ns")
     self.assertEqual(str(a), "urn:cts:ns:tg")
     a.work = "wk"
     self.assertEqual(a.work, "wk")
     self.assertEqual(str(a), "urn:cts:ns:tg.wk")
     a.reference = "1-2"
     self.assertEqual(a.reference, Reference("1-2"))
     self.assertEqual(str(a), "urn:cts:ns:tg.wk:1-2")
     a.version = "vs"
     self.assertEqual(a.version, "vs")
     self.assertEqual(str(a), "urn:cts:ns:tg.wk.vs:1-2")
Exemplo n.º 40
0
 def test_warning_on_empty(self):
     with self.assertRaises(ValueError):
         a = URN("urn:cts")
     with self.assertRaises(KeyError):
         a = URN("urn:cts:ns:tg.work:1")
         a.upTo(URN.VERSION)