pyview-web 0.3.0__py3-none-any.whl → 0.8.0a2__py3-none-any.whl

pyview/vendor/ibis/compiler.py

@@ -1,16 +1,14 @@
-from . import nodes
-from . import errors
-
+from . import errors, nodes
 
 # Token delimiters.
-comment_start = '{#'
-comment_end = '#}'
-print_start = '{{'
-print_end = '}}'
-eprint_start = '{$'
-eprint_end = '$}'
-instruction_start = '{%'
-instruction_end = '%}'
+comment_start = "{#"
+comment_end = "#}"
+print_start = "{{"
+print_end = "}}"
+eprint_start = "{$"
+eprint_end = "$}"
+instruction_start = "{%"
+instruction_end = "%}"
 
 
 # Returns the root node of the compiled node tree.
@@ -20,10 +18,9 @@ def compile(template_string, template_id):
 
 # Tokens come in four different types: TEXT, PRINT, EPRINT, and INSTRUCTION.
 class Token:
-
     def __init__(self, token_type, token_text, template_id, line_number):
         words = token_text.split()
-        self.keyword = words[0] if words else ''
+        self.keyword = words[0] if words else ""
         self.type = token_type
         self.text = token_text
         self.template_id = template_id
@@ -35,7 +32,6 @@ class Token:
 
 # The Lexer takes a template string as input and chops it into a list of Tokens.
 class Lexer:
-
     def __init__(self, template_string, template_id):
         self.template_string = template_string
         self.template_id = template_id
@@ -63,7 +59,7 @@ class Lexer:
         return False
 
     def advance(self):
-        if self.template_string[self.index] == '\n':
+        if self.template_string[self.index] == "\n":
             self.line_number += 1
         self.index += 1
 
@@ -84,7 +80,7 @@ class Lexer:
         start_line_number = self.line_number
         while self.index < len(self.template_string):
             if self.match(eprint_end):
-                text = self.template_string[start_index:self.index].strip()
+                text = self.template_string[start_index : self.index].strip()
                 self.tokens.append(Token("EPRINT", text, self.template_id, start_line_number))
                 self.index += len(eprint_end)
                 return
@@ -98,7 +94,7 @@ class Lexer:
         start_line_number = self.line_number
         while self.index < len(self.template_string):
             if self.match(print_end):
-                text = self.template_string[start_index:self.index].strip()
+                text = self.template_string[start_index : self.index].strip()
                 self.tokens.append(Token("PRINT", text, self.template_id, start_line_number))
                 self.index += len(print_end)
                 return
@@ -112,35 +108,33 @@ class Lexer:
         start_line_number = self.line_number
         while self.index < len(self.template_string):
             if self.match(instruction_end):
-                text = self.template_string[start_index:self.index].strip()
+                text = self.template_string[start_index : self.index].strip()
                 self.tokens.append(Token("INSTRUCTION", text, self.template_id, start_line_number))
                 self.index += len(instruction_end)
                 return
             self.advance()
-        msg = f"Unclosed instruction tag."
+        msg = "Unclosed instruction tag."
         raise errors.TemplateLexingError(msg, self.template_id, start_line_number)
 
     def read_text(self):
         start_index = self.index
         start_line_number = self.line_number
         while self.index < len(self.template_string):
-            if self.match(comment_start):
-                break
-            elif self.match(eprint_start):
-                break
-            elif self.match(print_start):
-                break
-            elif self.match(instruction_start):
+            if (
+                self.match(comment_start)
+                or self.match(eprint_start)
+                or self.match(print_start)
+                or self.match(instruction_start)
+            ):
                 break
             self.advance()
-        text = self.template_string[start_index:self.index]
+        text = self.template_string[start_index : self.index]
         self.tokens.append(Token("TEXT", text, self.template_id, start_line_number))
 
 
 # The Parser takes a template string as input, lexes it into a token stream, then compiles the
 # token stream into a tree of nodes.
 class Parser:
-
     def __init__(self, template_string, template_id):
         self.template_string = template_string
         self.template_id = template_id
@@ -173,8 +167,8 @@ class Parser:
                     stack[-1].exit_scope()
                     stack.pop()
                     expecting.pop()
-            elif token.keyword == '':
-                msg = f"Empty instruction tag."
+            elif token.keyword == "":
+                msg = "Empty instruction tag."
                 raise errors.TemplateSyntaxError(msg, token)
             else:
                 msg = f"Unrecognised instruction tag '{token.keyword}'."
@@ -182,10 +176,9 @@ class Parser:
 
         if expecting:
             token = stack[-1].token
-            msg = f"Unexpected end of template. "
+            msg = "Unexpected end of template. "
             msg += f"Ibis was expecting a closing '{expecting[-1]}' tag to close the "
             msg += f"'{token.keyword}' tag opened in line {token.line_number}."
             raise errors.TemplateSyntaxError(msg, token)
 
         return stack.pop()
-

pyview/vendor/ibis/context.py

@@ -1,19 +1,18 @@
 import datetime
-from . import errors
 
+from . import errors
 
 # User-configurable functions and variables available in all contexts.
 builtins = {
-    'now': datetime.datetime.now,
-    'range': range,
+    "now": datetime.datetime.now,
+    "range": range,
 }
 
 
 # A wrapper around a stack of dictionaries.
 class DataStack:
-
     def __init__(self):
-       self.stack = []
+        self.stack = []
 
     def __getitem__(self, key):
         for d in reversed(self.stack):
@@ -25,16 +24,17 @@ class DataStack:
 # A Context object is a wrapper around the user's input data. Its `.resolve()` method contains
 # the lookup-logic for resolving dotted variable names.
 class Context:
-
     def __init__(self, data_dict, strict_mode):
         # Stack of data dictionaries for the .resolve() method.
         self.data = DataStack()
 
         # Standard builtins.
-        self.data.stack.append({
-            'context': self,
-            'is_defined': self.is_defined,
-        })
+        self.data.stack.append(
+            {
+                "context": self,
+                "is_defined": self.is_defined,
+            }
+        )
 
         # User-configurable builtins.
         self.data.stack.append(builtins)
@@ -75,7 +75,7 @@ class Context:
     def resolve(self, varstring, token):
         words = []
         result = self.data
-        for word in varstring.split('.'):
+        for word in varstring.split("."):
             words.append(word)
             if hasattr(result, word):
                 result = getattr(result, word)
@@ -95,7 +95,7 @@ class Context:
 
     def is_defined(self, varstring):
         current = self.data
-        for word in varstring.split('.'):
+        for word in varstring.split("."):
             if hasattr(current, word):
                 current = getattr(current, word)
             else:
@@ -111,9 +111,8 @@ class Context:
 
 # Null type returned when a context lookup fails.
 class Undefined:
-
     def __str__(self):
-        return ''
+        return ""
 
     def __bool__(self):
         return False
@@ -135,4 +134,3 @@ class Undefined:
 
     def __ne__(self, other):
         return True
-

pyview/vendor/ibis/errors.py

@@ -1,6 +1,5 @@
 # Base class for all exception types raised by the template engine.
 class TemplateError(Exception):
-
     def __init__(self, msg):
         self.msg = msg
 
@@ -17,7 +16,6 @@ class TemplateLoadError(TemplateError):
 
 # This exception type is raised if the lexer cannot tokenize a template string.
 class TemplateLexingError(TemplateError):
-
     def __init__(self, msg, template_id, line_number):
         super().__init__(msg)
         self.template_id = template_id
@@ -29,7 +27,6 @@ class TemplateLexingError(TemplateError):
 
 # This exception type may be raised while a template is being compiled.
 class TemplateSyntaxError(TemplateError):
-
     def __init__(self, msg, token):
         super().__init__(msg)
         self.token = token
@@ -37,7 +34,6 @@ class TemplateSyntaxError(TemplateError):
 
 # This exception type may be raised while a template is being rendered.
 class TemplateRenderingError(TemplateError):
-
     def __init__(self, msg, token):
         super().__init__(msg)
         self.token = token
@@ -45,8 +41,6 @@ class TemplateRenderingError(TemplateError):
 
 # This exception type is raised in strict mode if a variable cannot be resolved.
 class UndefinedVariable(TemplateError):
-
     def __init__(self, msg, token):
         super().__init__(msg)
         self.token = token
-

pyview/vendor/ibis/filters.py

@@ -1,14 +1,14 @@
-import re
-import pprint
 import html
+import pprint
 import random
+import re
 
 from . import context
 
 try:
     import pygments
-    import pygments.lexers
     import pygments.formatters
+    import pygments.lexers
 except ImportError:
     pygments = None
 
@@ -29,7 +29,6 @@ filtermap = {}
 #
 # If no name is supplied the function name will be used.
 def register(nameorfunc=None):
-
     if callable(nameorfunc):
         filtermap[nameorfunc.__name__] = nameorfunc
         return nameorfunc
@@ -43,126 +42,126 @@ def register(nameorfunc=None):
 
 @register
 def argtest(*args):
-    """ Test filter: returns arguments as a concatenated string. """
-    return '|'.join(str(arg) for arg in args)
+    """Test filter: returns arguments as a concatenated string."""
+    return "|".join(str(arg) for arg in args)
 
 
 @register
 def default(obj, fallback):
-    """ Returns `obj` if `obj` is truthy, otherwise `fallback`. """
+    """Returns `obj` if `obj` is truthy, otherwise `fallback`."""
     return obj or fallback
 
 
 @register
-def dtformat(dt, format='%Y-%m-%d %H:%M'):
-    """ Formats a datetime object using the specified format string. """
+def dtformat(dt, format="%Y-%m-%d %H:%M"):
+    """Formats a datetime object using the specified format string."""
     return dt.strftime(format)
 
 
 @register
 def endswith(s, suffix):
-    """ True if the string ends with the specified suffix. """
+    """True if the string ends with the specified suffix."""
     return s.endswith(suffix)
 
 
 @register
-@register('e')
-@register('esc')
+@register("e")
+@register("esc")
 def escape(s, quotes=True):
-    """ Converts html syntax characters to character entities. """
+    """Converts html syntax characters to character entities."""
     return html.escape(s, quotes)
 
 
 @register
 def first(seq):
-    """ Returns the first element in the sequence `seq`. """
+    """Returns the first element in the sequence `seq`."""
     return seq[0]
 
 
 @register
 def firsth(html):
-    """ Returns the content of the first heading element. """
-    match = re.search(r'<h(\d)+[^>]*>(.*?)</h\1>', html, flags=re.DOTALL)
-    return match.group(2) if match else ''
+    """Returns the content of the first heading element."""
+    match = re.search(r"<h(\d)+[^>]*>(.*?)</h\1>", html, flags=re.DOTALL)
+    return match.group(2) if match else ""
 
 
 @register
 def firsth1(html):
-    """ Returns the content of the first h1 element. """
-    match = re.search(r'<h1[^>]*>(.*?)</h1>', html, flags=re.DOTALL)
-    return match.group(1) if match else ''
+    """Returns the content of the first h1 element."""
+    match = re.search(r"<h1[^>]*>(.*?)</h1>", html, flags=re.DOTALL)
+    return match.group(1) if match else ""
 
 
 @register
 def firstp(html):
-    """ Returns the content of the first p element. """
-    match = re.search(r'<p[^>]*>(.*?)</p>', html, flags=re.DOTALL)
-    return match.group(1) if match else ''
+    """Returns the content of the first p element."""
+    match = re.search(r"<p[^>]*>(.*?)</p>", html, flags=re.DOTALL)
+    return match.group(1) if match else ""
 
 
-@register('reversed')
+@register("reversed")
 def get_reversed(seq):
-    """ Returns a reverse iterator over the sequence `seq`. """
+    """Returns a reverse iterator over the sequence `seq`."""
     return reversed(seq)
 
 
 @register
 def index(seq, i):
-    """ Returns the ith element in the sequence `seq`. """
+    """Returns the ith element in the sequence `seq`."""
     return seq[i]
 
 
-@register('divisible_by')
+@register("divisible_by")
 def is_divisible_by(n, d):
-    """ True if the integer `n` is a multiple of the integer `d`. """
+    """True if the integer `n` is a multiple of the integer `d`."""
     return n % d == 0
 
 
-@register('even')
+@register("even")
 def is_even(n):
-    """ True if the integer `n` is even. """
+    """True if the integer `n` is even."""
     return n % 2 == 0
 
 
-@register('odd')
+@register("odd")
 def is_odd(n):
-    """ True if the integer `n` is odd. """
+    """True if the integer `n` is odd."""
     return n % 2 != 0
 
 
 @register
-def join(seq, sep=''):
-    """ Joins elements of the sequence `seq` with the string `sep`. """
+def join(seq, sep=""):
+    """Joins elements of the sequence `seq` with the string `sep`."""
     return sep.join(str(item) for item in seq)
 
 
 @register
 def last(seq):
-    """ Returns the last element in the sequence `seq`. """
+    """Returns the last element in the sequence `seq`."""
     return seq[-1]
 
 
-@register('len')
+@register("len")
 def length(seq):
-    """ Returns the length of the sequence `seq`. """
+    """Returns the length of the sequence `seq`."""
     return len(seq)
 
 
 @register
 def lower(s):
-    """ Returns the string `s` converted to lowercase. """
+    """Returns the string `s` converted to lowercase."""
     return s.lower()
 
 
-@register('pprint')
+@register("pprint")
 def prettyprint(obj):
-    """ Returns a pretty-printed representation of `obj`. """
+    """Returns a pretty-printed representation of `obj`."""
     return pprint.pformat(obj)
 
 
 @register
 def pygmentize(text, lang=None):
-    """ Applies syntax highlighting using Pygments.
+    """Applies syntax highlighting using Pygments.
 
     If no language is specified, Pygments will attempt to guess the correct
     lexer to use. If Pygments is not available or if an appropriate lexer
@@ -192,107 +191,102 @@ def pygmentize(text, lang=None):
 
 @register
 def random(seq):
-    """ Returns a random element from the sequence `seq`. """
+    """Returns a random element from the sequence `seq`."""
     return random.choice(seq)
 
 
-@register('repr')
+@register("repr")
 def to_repr(obj):
-    """ Returns the result of calling repr() on `obj`. """
+    """Returns the result of calling repr() on `obj`."""
     return repr(obj)
 
 
 @register
 def slice(seq, start, stop=None, step=None):
-    """ Returns the start:stop:step slice of the sequence `seq`. """
+    """Returns the start:stop:step slice of the sequence `seq`."""
     return seq[start:stop:step]
 
 
 @register
 def spaceless(html):
-    """ Strips all whitespace between html/xml tags. """
-    return re.sub(r'>\s+<', '><', html)
+    """Strips all whitespace between html/xml tags."""
+    return re.sub(r">\s+<", "><", html)
 
 
 @register
 def startswith(s, prefix):
-    """ True if the string starts with the specified prefix. """
+    """True if the string starts with the specified prefix."""
     return s.startswith(prefix)
 
 
-@register('str')
+@register("str")
 def to_str(obj):
-    """ Returns the result of calling str() on `obj`. """
+    """Returns the result of calling str() on `obj`."""
     return str(obj)
 
 
 @register
 def striptags(html):
-    """ Returns the string `html` with all html tags stripped. """
-    return re.sub(r'<[^>]*>', '', html)
+    """Returns the string `html` with all html tags stripped."""
+    return re.sub(r"<[^>]*>", "", html)
 
 
 @register
-def teaser(s, delimiter='<!-- more -->'):
-    """ Returns the portion of the string `s` before `delimiter`,
-    or an empty string if `delimiter` is not found. """
+def teaser(s, delimiter="<!-- more -->"):
+    """Returns the portion of the string `s` before `delimiter`,
+    or an empty string if `delimiter` is not found."""
     index = s.find(delimiter)
     if index == -1:
-        return ''
+        return ""
     else:
         return s[:index]
 
 
 @register
-@register('title')
+@register("title")
 def titlecase(s):
-    """ Returns the string `s` converted to titlecase. """
-    return re.sub(
-        r"[A-Za-z]+('[A-Za-z]+)?",
-        lambda m: m.group(0)[0].upper() + m.group(0)[1:],
-        s
-    )
+    """Returns the string `s` converted to titlecase."""
+    return re.sub(r"[A-Za-z]+('[A-Za-z]+)?", lambda m: m.group(0)[0].upper() + m.group(0)[1:], s)
 
 
 @register
-def truncatechars(s, n, ellipsis='...'):
-    """ Truncates the string `s` to at most `n` characters. """
+def truncatechars(s, n, ellipsis="..."):
+    """Truncates the string `s` to at most `n` characters."""
     if len(s) > n:
-        return s[:n - 3].rstrip(' .,;:?!') + ellipsis
+        return s[: n - 3].rstrip(" .,;:?!") + ellipsis
     else:
         return s
 
 
 @register
-def truncatewords(s, n, ellipsis=' [...]'):
-    """ Truncates the string `s` to at most `n` words. """
+def truncatewords(s, n, ellipsis=" [...]"):
+    """Truncates the string `s` to at most `n` words."""
     words = s.split()
     if len(words) > n:
-        return ' '.join(words[:n]) + ellipsis
+        return " ".join(words[:n]) + ellipsis
     else:
-        return ' '.join(words)
+        return " ".join(words)
 
 
 @register
 def upper(s):
-    """ Returns the string `s` converted to uppercase. """
+    """Returns the string `s` converted to uppercase."""
     return s.upper()
 
 
 @register
 def wrap(s, tag):
-    """ Wraps a string in opening and closing tags. """
-    return '<%s>%s</%s>' % (tag, str(s), tag)
+    """Wraps a string in opening and closing tags."""
+    return "<%s>%s</%s>" % (tag, str(s), tag)
 
 
 @register
 def if_undefined(obj, fallback):
-    """ Returns `obj` if `obj` is defined, otherwise `fallback`. """
+    """Returns `obj` if `obj` is defined, otherwise `fallback`."""
     return fallback if isinstance(obj, context.Undefined) else obj
 
 
 @register
 def is_defined(obj):
-    """ Returns true if `obj` is defined, otherwise false. """
+    """Returns true if `obj` is defined, otherwise false."""
     return not isinstance(obj, context.Undefined)
-

pyview/vendor/ibis/loaders.py

@@ -1,7 +1,7 @@
 import os
 
-from .template import Template
 from .errors import TemplateLoadError
+from .template import Template
 
 
 # Loads templates from the file system. Assumes files are utf-8 encoded. Compiled templates are
@@ -20,7 +20,6 @@ from .errors import TemplateLoadError
 #     template = loader('subdir/foo.txt')
 #
 class FileLoader:
-
     def __init__(self, base_dir):
         self.base_dir = base_dir
         self.cache = {}
@@ -32,7 +31,7 @@ class FileLoader:
         path = os.path.join(self.base_dir, filename)
         if os.path.isfile(path):
             try:
-                with open(path, encoding='utf-8') as file:
+                with open(path, encoding="utf-8") as file:
                     template_string = file.read()
             except OSError as err:
                 msg = f"FileLoader cannot load the template file '{filename}'."
@@ -42,14 +41,15 @@ class FileLoader:
             self.cache[filename] = template
             return template
 
-        msg = f"FileLoader with base '{self.base_dir}' cannot locate the template file '{filename}'."
+        msg = (
+            f"FileLoader with base '{self.base_dir}' cannot locate the template file '{filename}'."
+        )
         raise TemplateLoadError(msg)
 
 
 # Like FileLoader but templates are automatically recompiled if the underlying template file
 # is modified.
 class FileReloader:
-
     def __init__(self, base_dir):
         self.base_dir = base_dir
         self.cache = {}
@@ -63,7 +63,7 @@ class FileReloader:
                     return self.cache[filename][1]
 
             try:
-                with open(path, encoding='utf-8') as file:
+                with open(path, encoding="utf-8") as file:
                     template_string = file.read()
             except OSError as err:
                 msg = f"FileReloader cannot load the template file '{filename}'."
@@ -80,7 +80,6 @@ class FileReloader:
 # Loads templates from a dictionary of template strings. Templates are compiled once and cached for
 # future use.
 class DictLoader:
-
     def __init__(self, template_strings):
         self.templates = {}
         self.template_strings = template_strings