pylode 2.8.3__py2.py3-none-any.whl

pyLODE-2.8.3.dist-info/RECORD

@@ -0,0 +1,63 @@
+pylode/__init__.py,sha256=6i5ZH7ehVb_zv33sSaqx56EnlG5PJu--xw2DESnlOjU,220
+pylode/cli.py,sha256=Uloty2FLHUwVnSYuuwi0fdv0w8-XGuCblhMZtmzXtCw,6152
+pylode/common.py,sha256=ri3PtV_rmJ7XGNM4MuiFgT5xDAxdxMJTYQvF0yTVdO8,7461
+pylode/curies.py,sha256=NsL9RSeF3Gco_So1c5VJz-TwKUy8iq0PxiPUzjgPWxw,117546
+pylode/server.py,sha256=kXDLx2XlZ6NdKaYPuE7ZZ6JX7jvvEPLNKAzm-IbmVBg,793
+pylode/profiles/__init__.py,sha256=6Mx0ej4KSfGdtb_wiNjCRZHffbhvaNmXyo1jLp1HXzU,100
+pylode/profiles/base.py,sha256=_FJqsBGn-gSfFshZJQo97_PpUZaHlkgMXbXYZi13Zcs,18086
+pylode/profiles/ontdoc.py,sha256=x1G5RBQM1SrCJb13M9gf7IKDq6oDrDTWBEkQCOIXa8g,54835
+pylode/profiles/prof.py,sha256=BGfvP0540pb1Yz2ivHvJCF8nxMEp7T9kW5EvjEGnGTs,11910
+pylode/profiles/profile.py,sha256=qCLtBzEYapaZKKAAeSVLsFeBXhTkjPJldVOfS03MuYo,5234
+pylode/profiles/vocpub.py,sha256=9GX3PcjTvK4zl_x-0BLSC11-5Q0V2f9lOdEVWUYMS5w,25938
+pylode/style/pylode.css,sha256=R0pqa-isdcFiSMORLp5LIfdM-3eYKsenzue84C9FMJA,3645
+pylode/templates/agent.html,sha256=NTFTrA4Ji3CVnJAgw3JkL5WByIYmGSt0-wgUtDvg2kE,252
+pylode/templates/agent.md,sha256=sYpnepaPTooYNX3JbFSdo6Rf_Dc8fN4vV6jw1np96EY,207
+pylode/templates/namespaces.html,sha256=M-mDN1krRJWy2FAp9Vwcu5icPSfu0TM5Yfpeg1VQq8M,300
+pylode/templates/namespaces.md,sha256=NgiCxkgNb1uIZlBKBIRI7xPWGKw0BYqTyj-X3t7A1xs,106
+pylode/templates/orcid.html,sha256=o-2Z20AFnTqZZ92t7u-A_RofOYRh4LJaarKZznLwxBI,1905
+pylode/templates/orcid.md,sha256=gwN-ODYXRi-JBMWmH9ES7gMRAC6kxvZuiVHc04k7pPE,7
+pylode/templates/ontdoc/class.html,sha256=wJUQ_1yHpr-6moiVXz3mz7ShzEuPpTB-YkJN0tCFcFQ,3566
+pylode/templates/ontdoc/class.md,sha256=0nQGvPbAOpuIaypsx8_Cs9H7huTri2PuLypcp-uFv6o,1284
+pylode/templates/ontdoc/classes.html,sha256=f3i83ldj97wdbLnPCL-Sb8ye4V69CmpwMwSzqRP8H6g,347
+pylode/templates/ontdoc/classes.md,sha256=RFZj1u9DQqylrmq0XW1Vz3hi0ATrZeW1RPUfo3UeYB4,139
+pylode/templates/ontdoc/document.html,sha256=gUkGStgOzSos0cTw3ZjFYgAci0YksDzzL91u42rmECE,1656
+pylode/templates/ontdoc/document.md,sha256=n2FlmqDQcUw2XgQRlvf4JBey4UH3-ZPj6kx2Dg70Vdo,376
+pylode/templates/ontdoc/metadata.html,sha256=JrSxTuyX4Yd0kwMzQ2bWbVka2d8PrxCwP4FYMcOfGrs,4770
+pylode/templates/ontdoc/metadata.md,sha256=K1uHUemo0Y10Xa_F2qzIDlvkYrb-51lgQ6yOj9B129c,2259
+pylode/templates/ontdoc/named_individual.html,sha256=L6EMllxXtTl94YIRlOo8EGS1BYj78bblZT9VQEwqMcI,1833
+pylode/templates/ontdoc/named_individual.md,sha256=Uz7xAiKQU0AQufi9N7CzKhVXZBj0hXr2muL_3J2yFn4,560
+pylode/templates/ontdoc/named_individuals.html,sha256=5DIyP57yhcFZIQBwZWgp8dCnvgiwO_1TriJQuBoQztM,370
+pylode/templates/ontdoc/named_individuals.md,sha256=szOSZQXQJFq6cpJd-H4Tjkd3cT3vi_q3qXnVJBUsJ0Y,153
+pylode/templates/ontdoc/properties.html,sha256=Bgte2a-d8iusc5G8Otdev_3hGLrgAvp_ZIDh3LgBZIc,2080
+pylode/templates/ontdoc/properties.md,sha256=n7-cUtWzQkX-2ZBTsn7XNp-UADc6y1_SMbfABsYTSUQ,980
+pylode/templates/ontdoc/property.html,sha256=hllTJ5voVZP-4sBwnYaczV9Aa32ebnC6r9terZsj6dQ,4273
+pylode/templates/ontdoc/property.md,sha256=4ZNR0Nl-NHzYbxNO4YN-_c58npsEl37G9Bh3fmMbkKo,1302
+pylode/templates/prof/prof.html,sha256=hGY4UQfaKHMGLxfYAbvCtPbQ4yMWUGvAKfLzg0sc9Sg,1131
+pylode/templates/prof/prof.md,sha256=blbh-rk_OWkGeliFQjz1hLP-bf_os7hqlDHx3AdHZcI,340
+pylode/templates/prof/profile.html,sha256=HoS5qZmHWw32-vG2w1Je_XDxcxHbGnBKjYwdSVmdS2A,3557
+pylode/templates/prof/profile.md,sha256=qnsv5H_I4HbegGY1dvnxIPRv6Ru76u0K1JRPEA92mJI,1684
+pylode/templates/prof/resource_descriptor.html,sha256=d5Lbsl1tcXmHi0P4Bqu3fNUwpgWbYvBYvZzWyM6JmUg,1647
+pylode/templates/prof/resource_descriptor.md,sha256=llvHezZwlMQy6Z79pFrCgwJvQbQOJIGKdZi_5upnsws,532
+pylode/templates/vocpub/collection.html,sha256=oBF-NjxGV8X8XPiNDVEd7-LSBfmI6V3zre0Zo3Q_tO8,1591
+pylode/templates/vocpub/collection.md,sha256=bcVJoifPBI5I_3P-UOelEKN3bBAxX3Mmw9lcP6Cmlh0,873
+pylode/templates/vocpub/collections.html,sha256=T5iYEfieZ9YR-vHgbd7qdWKzOATM2Du00pfQsaHkX5g,400
+pylode/templates/vocpub/collections.md,sha256=dsTyLK-CnhviHaf8jNEfdD7gflH_Ng9eaWKbiTXEXCM,191
+pylode/templates/vocpub/concept.html,sha256=JCROzB9LnMhB3K2WHi3JN2siqOAxo4htXHup-dcSCu0,3670
+pylode/templates/vocpub/concept.md,sha256=jpbGZuYnYRLs1xfGo9ICkkmdiA3Wb7bFIU85Fryg9r0,1609
+pylode/templates/vocpub/concept_hierarchy.html,sha256=b9BTGN-toKq0EXd3eI0smn1J6IQopLumix9xyBNjuZY,2079
+pylode/templates/vocpub/concept_scheme.html,sha256=75Edx-QbD6lmRXxOx3Fn5cZ7IxZtOtMXZcM-JH1h59g,4171
+pylode/templates/vocpub/concept_scheme.md,sha256=jh690mXsiQDJpdLbDSPuISJSKp_LlJKyuu0eJEpgq-4,1916
+pylode/templates/vocpub/concepts.html,sha256=PT5ogyuTby8wgNvyCy9tIF9rFMTiP14tlt2B-mAdT_k,307
+pylode/templates/vocpub/concepts.md,sha256=dJSu1oZ7Dr_7faSeuQnehweHQEj95_gACITnPT4n9cg,160
+pylode/templates/vocpub/taxonomy.html,sha256=oZTm5q0Oim_jtyxHoFNL8jd1F2J35owENp1UOiglldk,1097
+pylode/templates/vocpub/taxonomy.md,sha256=LtbsBuOLWZiqcZOISVw6pSadsXftqBBuyiMg7hyyPe0,286
+pylode/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pylode/tests/test_ont_html_description.py,sha256=TGtdwSn7HjiK5wyPPXRj6oqSQlfoyBkZxmePgd9fes4,179
+pylode/tests/test_skos.py,sha256=r_oBy6cjS-8v4yr8Y_qHhQvo8EqibAKcCMAHmEbpCX0,214
+pylode/tests/tests_all.py,sha256=6w1njRCHH6TYOR6Oo5vCCaIUGn7YqTUdy0Jx-Rx7n4o,1578
+pyLODE-2.8.3.dist-info/LICENSE,sha256=DOLbiwXyZgqIMYgF59FBHa0-beH9-Ars22dMstVAwCM,35262
+pyLODE-2.8.3.dist-info/METADATA,sha256=lWfubz3_hvroDFAgzbtYWdvaZ1XhbM0W8uL0nVvDgx4,30581
+pyLODE-2.8.3.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
+pyLODE-2.8.3.dist-info/entry_points.txt,sha256=ke39luhrWgy_H-OR1BMTarUmb0U5HD0qc9NCDeov2AM,44
+pyLODE-2.8.3.dist-info/top_level.txt,sha256=abeq7Fnj2In1apCho3urrksoLurHqHeloZOV9KO0mss,7
+pyLODE-2.8.3.dist-info/RECORD,,

pyLODE-2.8.3.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.34.2)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

pyLODE-2.8.3.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pylode = pylode.cli:main
+

pyLODE-2.8.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+pylode

pylode/__init__.py

@@ -0,0 +1,5 @@
+from rdflib.plugin import register, Serializer
+register("json-ld", Serializer, "rdflib_jsonld.serializer", "JsonLDSerializer")
+
+from .common import *
+from .profiles import OntDoc, Prof, VocPub, PROFILES, RDF_MEDIA_TYPES

pylode/cli.py

@@ -0,0 +1,191 @@
+import argparse
+import os
+from os import path
+import shutil
+import sys
+from os.path import dirname, realpath
+sys.path.insert(0, dirname(dirname(realpath(__file__))))
+from pylode import RDF_FILE_EXTENSIONS, MakeDocco
+
+
+def is_valid_file(parser, arg):
+    try:
+        return open(arg, "r")
+    except:
+        parser.error("The file %s does not exist!" % arg)
+
+
+# used to capture graph parsing and content errors
+class RdfGraphError(Exception):
+    pass
+
+
+def main(args=None):
+    # read the input ontology file into a graph
+    parser = argparse.ArgumentParser()
+    overarching_group = parser.add_mutually_exclusive_group()
+    inputs_group = overarching_group.add_mutually_exclusive_group()
+
+    inputs_group.add_argument(
+        "-i",
+        "--inputfile",
+        help="The RDF ontology file you wish to generate HTML for. "
+        "Must be in either Turtle, RDF/XML, JSON-LD or N-Triples formats indicated by the file type extensions:"
+        "{} respectively.".format(", ".join(RDF_FILE_EXTENSIONS)),
+        type=lambda x: is_valid_file(parser, x),
+    )
+
+    inputs_group.add_argument(
+        "-u",
+        "--url",
+        help="The RDF ontology you wish to generate HTML for, online. "
+        "Must be an absolute URL that can be resolved to RDF, preferably via Content Negotiation.",
+    )
+
+    overarching_group.add_argument(
+        "-lp",
+        "--listprofiles",
+        help="This flag, if used, must be the only flag supplied. It will cause the program to list all the ontology"
+        " documentation profiles that it supports, indicating both their URI and their short token for use with the"
+        " -p (--profile) flag when creating HTML documentation",
+        action="store_true",
+    )
+
+    parser.add_argument(
+        "-p",
+        "--profile",
+        help="A profile - a specified information model - for an ontology. You can indicate this via the profile's URI"
+        "or its token. The list of profiles - URIs and their corresponding tokens - supported by pyLODE, can be "
+        "found by running the program with the flag -lp or --listprofiles.",
+        default="ontdoc",
+    )
+
+    parser.add_argument(
+        "-c",
+        "--css",
+        help="Whether (true) or not (false) to copy the default CSS file to the output directory.",
+        choices=["true", "false"],
+        default="false",
+    )
+
+    parser.add_argument(
+        "-xc",
+        "--excludecss",
+        help="Whether (true) or not (false) to exclude the standard pyLODE CSS content from an HTML file output.",
+        choices=["true", "false"],
+        default="false",
+    )
+
+    parser.add_argument(
+        "-q",
+        "--getcuriesonline",
+        help="Whether (true) or not (false) to look up CURIEs for unknown namespaces using http://prefix.cc.",
+        choices=["true", "false"],
+        default="false",
+    )
+
+    parser.add_argument(
+        "-o",
+        "--outputfile",
+        help="A name you wish to assign to the output file. Will be postfixed with .html/.md if not already added. If "
+             "no output file is given, output will be printed to screen",
+        default=None
+    )
+
+    parser.add_argument(
+        "-f",
+        "--outputformat",
+        help="The output format of the documentation.",
+        choices=["html", "md"],
+        default="html",
+    )
+
+    parser.add_argument(
+        "-v",
+        "--version",
+        help="The version of this copy of pyLODE.",
+        action="store_true"
+    )
+
+    args = parser.parse_args()
+
+    if args.listprofiles:
+        print(MakeDocco.list_profiles())
+        exit()
+    elif args.version:
+        from pylode import __version__
+        print(__version__)
+        exit()
+    elif args.inputfile or args.url:
+        if args.excludecss == "true":
+            exclude_css = True
+        else:
+            exclude_css = False
+
+        # args are present so getting RDF from input file or uri into an rdflib Graph
+        if args.inputfile:
+            h = MakeDocco(
+                input_data_file=args.inputfile,
+                outputformat=args.outputformat,
+                profile=args.profile,
+                exclude_css=exclude_css
+            )
+        elif args.url:
+            h = MakeDocco(
+                input_uri=args.url,
+                outputformat=args.outputformat,
+                profile=args.profile,
+                exclude_css=exclude_css
+            )
+        else:
+            # we have neither an input file or a URI supplied
+            parser.error(
+                "Either an input file or a url is required to access the ontology's RDF"
+            )
+
+        if args.profile:
+            if not MakeDocco.is_supported_profile(args.profile):
+                parser.error("The profile you requested, '{}', is not supported. "
+                             "Please choose from those given by List Profiles (-lp)".format(args.profile))
+    else:
+        parser.error("An ontology source (-i/--inputfile or -u/--url) is required")
+
+    # here we have a parsed graph from either a local file or a URI
+
+    # set up output directories and resources
+    main_dir = path.dirname(path.realpath(__file__))
+    style_dir = path.join(main_dir, "style")
+    if h.publication_dir == "":
+        h.publication_dir = "."
+    os.makedirs(h.publication_dir, exist_ok=True)
+
+    # include CSS
+    if args.css == "true":
+        shutil.copyfile(
+            path.join(style_dir, "pylode.css"), path.join(h.publication_dir, "style.css")
+        )
+
+    if args.outputfile is not None:
+        output_file_name = (
+            args.outputfile if args.outputfile else "doc.html"
+        )
+
+        if args.outputformat == "html":
+            if not output_file_name.endswith(".html"):
+                output_file_name += ".html"
+        elif args.outputformat == "md":
+            if not output_file_name.endswith(".md"):
+                output_file_name += ".md"
+
+        # generate the HTML doc
+        h.document(destination=output_file_name)
+
+        print("Finished. {} documentation in {}".format(args.profile, output_file_name))
+    else:
+        print(h.document())
+
+
+if __name__ == "__main__":
+    import sys
+
+    main(sys.argv[1:])

pylode/common.py

@@ -0,0 +1,191 @@
+from os import path
+import requests
+from rdflib import util, Graph
+
+VERSION = "2.8.3"
+APP_DIR = path.dirname(path.realpath(__file__))
+TEMPLATES_DIR = path.join(path.dirname(path.realpath(__file__)), "templates")
+STYLE_DIR = path.join(path.dirname(path.realpath(__file__)), "style")
+RDF_FILE_EXTENSIONS = [".rdf", ".owl", ".ttl", ".n3", ".nt", ".json"]
+RDF_SERIALIZER_MAP = {
+    "text/turtle": "turtle",
+    "text/n3": "n3",
+    "application/n-triples": "nt",
+    "application/ld+json": "json-ld",
+    "application/rdf+xml": "xml",
+    # Some common but incorrect mimetypes
+    "application/rdf": "xml",
+    "application/rdf xml": "xml",
+    "application/json": "json-ld",
+    "application/ld json": "json-ld",
+    "text/ttl": "turtle",
+    "text/turtle;charset=UTF-8": "turtle",
+    "text/ntriples": "nt",
+    "text/n-triples": "nt",
+    "text/plain": "nt",  # text/plain is the old/deprecated mimetype for n-triples
+}
+
+
+from .profiles import OntDoc, Prof, VocPub, PROFILES
+
+
+class MakeDocco:
+    def __init__(self, input_data_file=None, input_uri=None, data=None, outputformat="html", exclude_css=False, get_curies_online=False, profile="ontdoc"):
+        """This class receives all of the variables needed to specify how to make documentation from an input RDF source
+
+        :param input_data_file: An RDF file
+        :type input_data_file: path (string)
+        :param input_uri: A URI resolving to RDF data
+        :type input_uri: A URI (string)
+        :param data: RDF data
+        :type data: Python varaible (string)
+        :param outputformat: The desired output format form the list of supported formats (currently either "html" (default) or "md" for Markdown
+        :type outputformat: string (one of "html" or "md")
+        :param exclude_css: Whether (True, default) or not (False) to include styling CSS within HTML outputs (as oposed to producing a separate style.css file)
+        :type exclude_css: boolean
+        :param get_curies_online: Whether (True) or not (False, default) to search prefix.cc online for additional URI prefixes
+        :type get_curies_online: boolean
+        :param profile: When document profile, from a supported set, to use. Currently supported is "ontdoc" (profile of OWL) or "skosp" (profile of SKOS). See `list_profiles()` for full list of profiles.
+        :type profile: string (one of "ontdoc" or "skosp")
+        """
+        self.profile_selected = profile
+
+        if outputformat not in ["html", "md"]:
+            self.outputformat = "html"
+        else:
+            self.outputformat = outputformat
+
+        self.exclude_css = exclude_css
+        self.get_curies_online = get_curies_online
+
+        if profile not in PROFILES.keys():
+            print("The profile you've selected, {}, is not recognised so the default profile, {} is being used. "
+                  "Known profiles are: {}".format(profile, "ontdoc", ", ".join(PROFILES.keys())))
+            self.profile_selected = "ontdoc"
+        else:
+            self.profile_selected = profile
+
+        # shared variables
+        if input_data_file is not None:
+            self._parse_input_data_file(input_data_file)
+        elif input_uri is not None:
+            self._parse_input_uri(input_uri)
+        elif data is not None:
+            self._parse_data(data)
+        else:
+            raise Exception("You must supply either an input file or a URI for your ontology's RDF")
+
+    def _parse_input_data_file(self, input_data_file):
+        if hasattr(input_data_file, "name"):
+            file_name = str(input_data_file.name)
+        elif input_data_file is not None:
+            file_name = str(input_data_file)
+
+        if not file_name.endswith(tuple(RDF_FILE_EXTENSIONS)):
+            raise Exception(
+                "If supplying an input RDF file, it must end with one of the following file type extensions: {}."
+                    .format(
+                        ", ".join(RDF_FILE_EXTENSIONS)
+                    )
+                )
+        else:
+            fmt = (
+                "json-ld"
+                if file_name.endswith(".json") or file_name.endswith(".jsonld")
+                else util.guess_format(file_name)
+            )
+
+            self.G = Graph().parse(file_name, format=fmt)
+            self.source_info = (file_name, fmt)
+            self.publication_dir = path.dirname(file_name)
+
+    def _parse_input_uri(self, uri):
+        r = requests.get(
+            uri, headers={"Accept": ", ".join(RDF_SERIALIZER_MAP.keys())}
+        )
+        # get RDF format from Media Type
+        media_type = r.headers.get("Content-Type").split(";")[0]  # splitting off any ;charset=...
+        if RDF_SERIALIZER_MAP.get(media_type):
+            fmt = RDF_SERIALIZER_MAP.get(media_type)
+        else:
+            fmt = (
+                "json-ld"
+                if media_type == "application/ld+json"
+                or media_type == "application/json"
+                else None
+            )
+
+        if fmt is None:
+            raise Exception(
+                "Could not parse the supplied URI. The RDF format could not be determined from Media Type "
+                "({} was given) or from a file extension".format(media_type)
+            )
+
+        self.G = Graph().parse(data=r.text, format=fmt)
+        self.source_info = (uri, fmt)
+        self.publication_dir = path.join(
+            path.dirname(path.realpath(__file__)), "output_files"
+        )
+
+    def _parse_data(self, data):
+        self.G = Graph().parse(data=data, format="turtle")
+        self.source_info = ("input.ttl", "turtle")
+        self.publication_dir = path.dirname(path.realpath(__file__))
+
+    @classmethod
+    def list_profiles(cls):
+        s = ""
+        for k, v in PROFILES.items():
+            s += "{}: {}\n".format(k, v)
+
+        return s
+
+    @classmethod
+    def is_supported_profile(cls, profile_key):
+        is_supported = False
+        for k, v in PROFILES.items():
+            if profile_key == k or profile_key == v.uri:
+                is_supported = True
+
+        return is_supported
+
+    def document(self, destination=None):
+        if self.profile_selected == "prof":
+            p = Prof(
+                self.G,
+                self.source_info,
+                outputformat=self.outputformat,
+                exclude_css=self.exclude_css,
+                default_language="en",
+                get_curies_online=self.get_curies_online
+            )
+        elif self.profile_selected == "vocpub":
+            p = VocPub(
+                self.G,
+                self.source_info,
+                outputformat=self.outputformat,
+                exclude_css=self.exclude_css,
+                default_language="en",
+                get_curies_online=self.get_curies_online
+            )
+        else:
+            p = OntDoc(
+                self.G,
+                self.source_info,
+                outputformat=self.outputformat,
+                exclude_css=self.exclude_css,
+                default_language="en",
+                get_curies_online=self.get_curies_online
+            )
+
+        if destination is not None:
+            doc = p.generate_document()
+            try:
+                with open(destination, "w") as f:
+                    f.write(doc)
+            except Exception as e:
+                print(e)
+                raise Exception("The file you specified as 'destination' could not be written to. You specified {}.".format(destination))
+
+        else:
+            return p.generate_document()