FastAPI default

Author: nicholascar

pyldapi/__init__.py

@@ -6,7 +6,7 @@
 from pyldapi.profile import Profile
 from pyldapi.helpers import setup
 
-__version__ = '3.12'
+__version__ = '4.0'
 
 __all__ = [
     'Renderer',

pyldapi/data.py

@@ -0,0 +1,21 @@
+MEDIATYPE_NAMES = {
+    "text/html": "HTML",
+    "text/turtle": "Turtle",
+    "application/rdf+xml": "RDF/XML",
+    "application/ld+json": "JSON-LD",
+    "application/json": "JSON",
+    "application/n-triples": "N-triples",
+}
+RDF_MEDIATYPES = [
+    "text/turtle",
+    "application/rdf+xml",
+    "application/ld+json",
+    "application/n-triples",
+]
+RDF_FILE_EXTS = {
+    "text/turtle": "ttl",
+    "application/rdf+xml": "rdf",
+    "application/ld+json": "jsonld",
+    "application/n-triples": "nt",
+    "text/n3": "n3",
+}

pyldapi/renderer.py

@@ -1,6 +1,8 @@
 # -*- coding: utf-8 -*-
 from abc import ABCMeta
 
+from pathlib import Path
+
 from fastapi import Response
 from fastapi.responses import JSONResponse
 from fastapi.templating import Jinja2Templates
@@ -12,43 +14,23 @@
 from pyldapi.exceptions import ProfilesMediatypesException
 import re
 import connegp
+from .data import MEDIATYPE_NAMES, RDF_MEDIATYPES
 
-templates = Jinja2Templates(directory="templates")
-MEDIATYPE_NAMES = None
+templates_dir = Path(__file__).parent.parent / "pyldapi" / "templates"
+templates = Jinja2Templates(directory=str(templates_dir))
 
 
 class Renderer(object, metaclass=ABCMeta):
     """
     Abstract class as a parent for classes that validate the profiles & mediatypes for an API-delivered resource (typically
     either registers or objects) and also creates an 'alternates profile' for them, based on all available profiles & mediatypes.
     """
-    global MEDIATYPE_NAMES
-
-    RDF_MEDIA_TYPES = ['text/turtle', 'application/rdf+xml', 'application/ld+json', 'text/n3', 'application/n-triples']
-    RDF_SERIALIZER_TYPES_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/ntriples": "nt",
-        "text/n-triples": "nt",
-        "text/plain": "nt",  # text/plain is the old/deprecated mimetype for n-triples
-    }
 
     def __init__(self,
                  request,
                  instance_uri,
                  profiles,
                  default_profile_token,
-                 alternates_template=None,
-                 **kwargs
                  ):
         """
         Constructor
@@ -73,9 +55,6 @@ def __init__(self,
         self.request = request
         self.instance_uri = instance_uri
 
-        # self.mediatype_names = kwargs.get('MEDIATYPE_NAMES')
-        self.local_uris = kwargs.get('LOCAL_URIS')
-
         # ensure alternates token isn't hogged by user
         for k, v in profiles.items():
             if k == 'alternates':
@@ -87,7 +66,7 @@ def __init__(self,
             'http://www.w3.org/ns/dx/conneg/altr',  # the ConnegP URI for Alt Rep Data Model
             'Alternate Representations',
             'The representation of the resource that lists all other representations (profiles and Media Types)',
-            ['text/html', 'application/json'] + self.RDF_MEDIA_TYPES,
+            ['text/html', 'application/json'] + RDF_MEDIATYPES,
             'text/html',
             languages=['en'],  # default 'en' only for now
         )
@@ -105,9 +84,6 @@ def __init__(self,
 
         self.default_profile_token = default_profile_token
 
-        # TODO: supply an alternates.html template
-        self.alt_template = alternates_template
-
         # get profile & mediatype for this request, flag any errors but do not except out
         self.profile = self._get_profile()
         self.mediatype = self._get_mediatype()
@@ -451,20 +427,7 @@ def _make_rdf_response(self, graph, mimetype=None, headers=None, delete_graph=Tr
         if headers is None:
             headers = self.headers
 
-        if mimetype is not None:
-            response_mimetype = mimetype
-            serial_mediatype = self.RDF_SERIALIZER_TYPES_MAP.get(mimetype)
-        elif self.mediatype is not None:
-            response_mimetype = self.mediatype
-            if self.mediatype in ['application/rdf+json', 'application/json']:
-                serial_mediatype = 'json-ld'
-            else:
-                serial_mediatype = self.RDF_SERIALIZER_TYPES_MAP.get(self.mediatype)
-        else:
-            serial_mediatype = "turtle"
-            response_mimetype = "text/turtle"
-
-        response_text = graph.serialize(format=serial_mediatype, encoding='utf-8')
+        response_text = graph.serialize(format=mimetype or "text/turtle")
 
         if delete_graph:
             # destroy the triples in the triplestore, then delete the triplestore
@@ -475,11 +438,34 @@ def _make_rdf_response(self, graph, mimetype=None, headers=None, delete_graph=Tr
 
         return Response(
             response_text,
-            media_type=response_mimetype,
+            media_type=mimetype,
             headers=headers
         )
 
-    def _render_alt_profile_html(self, template_context=None):
+    def _render_alt_profile_html(
+            self,
+            alt_template: str = "alt.html",
+            additional_alt_template_context=None,
+            alt_template_context_replace=False
+    ):
+        """Renders the Alternates Profile in HTML
+
+        If an alt_template value (str, file name) is given, a template of that name will be looked for in the app's
+        template directory, else alt.html will be used.
+
+        If a dictionary is given for additional_alt_template_context, this will either replace the standard template
+        context, if alt_template_context_replace is True, or just be added to it, if alt_template_context_replace is
+        False
+
+        :param alt_template: the name of the template to use
+        :type alt_template: str (file name, within the application's templates directory)
+        :param additional_alt_template_context: Additional or complete context for the template
+        :type additional_alt_template_context: dict
+        :param alt_template_context_replace: To replace (True) or add to (False) the standard template context
+        :type alt_template_context_replace: bool
+        :return: a rendered template (HTML)
+        :rtype: TemplateResponse
+        """
         profiles = {}
         for token, profile in self.profiles.items():
             profiles[token] = {
@@ -495,13 +481,16 @@ def _render_alt_profile_html(self, template_context=None):
             'uri': self.instance_uri,
             'default_profile_token': self.default_profile_token,
             'profiles': profiles,
-            'MEDIATYPE_NAMES': MEDIATYPE_NAMES,
+            'mediatype_names': MEDIATYPE_NAMES,
             'request': self.request
         }
-        if template_context is not None and isinstance(template_context, dict):
-            _template_context.update(template_context)
+        if additional_alt_template_context is not None and isinstance(additional_alt_template_context, dict):
+            if alt_template_context_replace:
+                _template_context = additional_alt_template_context
+            else:
+                _template_context.update(additional_alt_template_context)
 
-        return templates.TemplateResponse(self.alt_template or 'alt.html',
+        return templates.TemplateResponse(alt_template,
                                           context=_template_context,
                                           headers=self.headers)
 
@@ -531,7 +520,7 @@ def _render_alt_profile(self):
             return self
         if self.mediatype == 'text/html':
             return self._render_alt_profile_html()
-        elif self.mediatype in Renderer.RDF_MEDIA_TYPES:
+        elif self.mediatype in RDF_MEDIATYPES:
             return self._render_alt_profile_rdf()
         else:  # application/json
             return self._render_alt_profile_json()

pyldapi/renderer_container.py

@@ -1,4 +1,6 @@
 # -*- coding: utf-8 -*-
+from pathlib import Path
+
 from fastapi import Response
 from fastapi.responses import JSONResponse
 from fastapi.templating import Jinja2Templates
@@ -7,17 +9,17 @@
 from pyldapi.renderer import Renderer
 from pyldapi.profile import Profile
 from pyldapi.exceptions import ProfilesMediatypesException, CofCTtlError
+from .data import RDF_MEDIATYPES, MEDIATYPE_NAMES
 
-templates = Jinja2Templates(directory="templates")
-MEDIATYPE_NAMES = None
+templates_dir = Path(__file__).parent.parent / "pyldapi" / "templates"
+templates = Jinja2Templates(directory=str(templates_dir))
 
 
 class ContainerRenderer(Renderer):
     """
     Specific implementation of the abstract Renderer for displaying Register information
     """
-    DEFAULT_ITEMS_PER_PAGE = 20
-    global MEDIATYPE_NAMES
+    DEFAULT_ITEMS_PER_PAGE = 100
 
     def __init__(self,
                  request,
@@ -32,9 +34,7 @@ def __init__(self,
                  profiles=None,
                  default_profile_token=None,
                  super_register=None,
-                 page_size_max=1000,
-                 register_template=None,
-                 **kwargs):
+                 page_size_max=1000):
         """
         Constructor
 
@@ -63,9 +63,9 @@ def __init__(self,
         :type default_profile_token: str
         :param super_register: A super-Register URI for this register. Can be within this API or external.
         :type super_register: str
-        :param register_template: The Jinja2 template to use for rendering the HTML profile of the register. If None,
+        :param members_template: The Jinja2 template to use for rendering the HTML profile of the register. If None,
         then it will default to try and use a template called :code:`alt.html`.
-        :type register_template: str or None
+        :type members_template: str or None
         :param per_page: Number of items to show per page if not specified in request. If None, then it will default to
         RegisterRenderer.DEFAULT_ITEMS_PER_PAGE.
         :type per_page: int or None
@@ -84,7 +84,7 @@ def __init__(self,
                 'https://w3id.org/profile/mem',
                 'Members Profile',
                 'A very basic RDF data model-only profile that lists the sub-items (members) of collections (rdf:Bag)',
-                ['text/html'] + Renderer.RDF_MEDIA_TYPES,
+                ['text/html'] + RDF_MEDIATYPES,
                 'text/html'
             )
         })
@@ -95,8 +95,7 @@ def __init__(self,
             request,
             instance_uri,
             profiles,
-            default_profile_token,
-            **kwargs
+            default_profile_token
          )
         if self.vf_error is None:
             self.label = label
@@ -120,9 +119,7 @@ def __init__(self,
 
             self.super_register = super_register
             self.page_size_max = page_size_max
-            self.members_template = register_template
             self.paging_error = self._paging()
-            self.template_extras = kwargs
 
     def _paging(self):
         # calculate last page
@@ -218,15 +215,12 @@ def render(self):
                 return Response(self.paging_error, status_code=400, media_type='text/plain')
         return response
 
-    def _render_mem_profile_html(self, template_context=None):
-        # pagination = Pagination(
-        #     members_uri=self.instance_uri,
-        #     page=self.page,
-        #     per_page=self.per_page,
-        #     total=self.members_total_count,
-        #     page_parameter='page',
-        #     per_page_parameter='per_page'
-        # )
+    def _render_mem_profile_html(
+            self,
+            mem_template: str = "mem.html",
+            additional_mem_template_context=None,
+            mem_template_context_replace=False
+    ):
         _template_context = {
             'uri': self.instance_uri,
             'label': self.label,
@@ -240,19 +234,18 @@ def _render_mem_profile_html(self, template_context=None):
             'prev_page': self.prev_page,
             'next_page': self.next_page,
             'last_page': self.last_page,
-            'MEDIATYPE_NAMES': MEDIATYPE_NAMES,
-            # 'pagination': pagination,
+            'mediatype_names': MEDIATYPE_NAMES,
             'request': self.request
         }
-        if self.template_extras is not None:
-            _template_context.update(self.template_extras)
-        if template_context is not None and isinstance(template_context, dict):
-            _template_context.update(template_context)
+        if additional_mem_template_context is not None and isinstance(additional_mem_template_context, dict):
+            if mem_template_context_replace:
+                _template_context = additional_mem_template_context
+            else:
+                _template_context.update(additional_mem_template_context)
 
-        return templates.TemplateResponse(
-                name=self.members_template or 'members.html',
-                context=_template_context,
-                headers=self.headers)
+        return templates.TemplateResponse(mem_template,
+                                          context=_template_context,
+                                          headers=self.headers)
 
     def _generate_mem_profile_rdf(self):
         g = Graph()
@@ -337,9 +330,8 @@ class ContainerOfContainersRenderer(ContainerRenderer):
 
     This sub-class auto-fills many of the :class:`.RegisterRenderer` options.
     """
-    global MEDIATYPE_NAMES
 
-    def __init__(self, request, instance_uri, label, comment, profiles, cofc_file_path, default_profile_token='mem', *args, **kwargs):
+    def __init__(self, request, instance_uri, label, comment, profiles, cofc_file_path, default_profile_token='mem'):
         """
         Constructor
 

pyldapi/templates/alt.html

@@ -19,14 +19,17 @@ <h4>Default Profile: <a href="{{ request.base_url }}?_profile={{ default_profile
                     <td style="padding-right: 30px;"><a href="{{ request.base_url }}?_profile={{ token }}&_mediatype={{ vals['default_mediatype'] }}">{{ token }}</a></td>
                     <td>{{ vals['label'] }}</td>
                     <td>
-                    {% for f in vals['mediatypes'] %}
-                        <a href="{{ request.base_url }}?_profile={{ token }}&_mediatype={{ f }}">{{ f }}</a><br />
-                    {% endfor %}
+                        {% for f in vals['mediatypes'] -%}
+                        {% if f in mediatype_names -%}
+                          <a href="{{ request.base_url }}?_profile={{ token }}&_mediatype={{ f }}">{{ mediatype_names[f] }}</a><br />
+                        {% else -%}
+                            <a href="{{ request.base_url }}?_profile={{ token }}&_mediatype={{ f }}">{{ f }}</a><br />
+                        {% endif %}{% endfor %}
                     </td>
                     <td style="text-align: center;">
-                    {% for l in vals['languages'] %}
+                    {%- for l in vals['languages'] %}
                         <a href="{{ request.base_url }}?_profile={{ token }}&_lang={{ l }}">{{ l }}</a><br />
-                    {% endfor %}
+                    {% endfor -%}
                     </td>
                     <td>{{ vals['comment'] }}</td>
                     {% if vals['namespace'] is not none %}