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

pyview/vendor/ibis/nodes.py

@@ -1,17 +1,17 @@
 import ast
+import collections
+import itertools
 import operator
 import re
-import itertools
-import collections
-from pyview.vendor import ibis
 from typing import Any, Callable
 
-from . import utils
-from . import filters
-from . import errors
-from .tree import PartsTree
 from markupsafe import Markup, escape
 
+from pyview.vendor import ibis
+
+from . import errors, filters, utils
+from .tree import PartsTree, StreamComprehension
+
 # Dictionary of registered keywords for instruction tags.
 instruction_keywords = {}
 
@@ -53,7 +53,6 @@ def register(keyword, endword=None):
 #     foo.bar.baz('bam')|filter(25, 'text')
 #
 class Expression:
-
     re_func_call = re.compile(r"^([\w.]+)\((.*)\)$")
     re_varstring = re.compile(r"^[\w.]+$")
 
@@ -99,9 +98,7 @@ class Expression:
         for filter_expr in filter_list:
             _, filter_name, filter_args = self._try_parse_as_func_call(filter_expr)
             if filter_name in filters.filtermap:
-                self.filters.append(
-                    (filter_name, filters.filtermap[filter_name], filter_args)
-                )
+                self.filters.append((filter_name, filters.filtermap[filter_name], filter_args))
             else:
                 msg = f"Unrecognised filter name '{filter_name}'."
                 raise errors.TemplateSyntaxError(msg, self.token)
@@ -154,9 +151,7 @@ class Node:
             raise
         except Exception as err:
             if token:
-                tagname = (
-                    f"'{token.keyword}'" if token.type == "INSTRUCTION" else token.type
-                )
+                tagname = f"'{token.keyword}'" if token.type == "INSTRUCTION" else token.type
                 msg = f"An unexpected error occurred while parsing the {tagname} tag: "
                 msg += f"{err.__class__.__name__}: {err}"
             else:
@@ -184,9 +179,7 @@ class Node:
                     if self.token.type == "INSTRUCTION"
                     else self.token.type
                 )
-                msg = (
-                    f"An unexpected error occurred while rendering the {tagname} tag: "
-                )
+                msg = f"An unexpected error occurred while rendering the {tagname} tag: "
                 msg += f"{err.__class__.__name__}: {err}"
             else:
                 msg = f"Unexpected rendering error: {err.__class__.__name__}: {err}"
@@ -285,13 +278,12 @@ class PrintNode(Node):
                 if content:
                     break
 
-        return (
-            str(content) if isinstance(content, Markup) else str(escape(str(content)))
-        )
+        return str(content) if isinstance(content, Markup) else str(escape(str(content)))
 
 
 NodeVisitor = Callable[[Node, Any], Any]
 
+
 # ForNodes implement `for ... in ...` looping over iterables.
 #
 #     {% for <var> in <expr> %} ... [ {% empty %} ... ] {% endfor %}
@@ -302,13 +294,12 @@ NodeVisitor = Callable[[Node, Any], Any]
 #
 @register("for", "endfor")
 class ForNode(Node):
-
     regex = re.compile(r"for\s+(\w+(?:,\s*\w+)*)\s+in\s+(.+)")
 
     def process_token(self, token):
         match = self.regex.match(token.text)
         if match is None:
-            msg = f"Malformed 'for' tag."
+            msg = "Malformed 'for' tag."
             raise errors.TemplateSyntaxError(msg, token)
         self.loopvars = [var.strip() for var in match.group(1).split(",")]
         self.expr = Expression(match.group(2), token)
@@ -327,9 +318,9 @@ class ForNode(Node):
                 context.push()
                 if unpack:
                     try:
-                        unpacked = dict(zip(self.loopvars, item))
+                        unpacked = dict(zip(self.loopvars, item, strict=False))
                     except Exception as err:
-                        msg = f"Unpacking error."
+                        msg = "Unpacking error."
                         raise errors.TemplateRenderingError(msg, self.token) from err
                     else:
                         context.update(unpacked)
@@ -384,11 +375,23 @@ class ForNode(Node):
         }
 
     def tree_parts(self, context):
+        # Import here to avoid circular imports
+        from pyview.stream import Stream
+
         output = []
 
         def visitor(node, ctx):
             output.append(node.tree_parts(ctx))
 
+        # Get the collection to check if it's a Stream
+        collection = self.expr.eval(context)
+
+        # Check if this is a Stream
+        if isinstance(collection, Stream):
+            self.visit_nodes(context, visitor)
+            return StreamComprehension(parts=output, stream=collection)
+
+        # Regular collection - use standard visit
         self.visit_nodes(context, visitor)
         return output
 
@@ -421,7 +424,6 @@ class EmptyNode(Node):
 # Note that explicit brackets are not supported.
 @register("if", "endif")
 class IfNode(Node):
-
     condition = collections.namedtuple("Condition", "negated lhs op rhs")
 
     re_condition = re.compile(
@@ -484,7 +486,7 @@ class IfNode(Node):
             else:
                 result = operator.truth(cond.lhs.eval(context))
         except Exception as err:
-            msg = f"An exception was raised while evaluating the condition in the "
+            msg = "An exception was raised while evaluating the condition in the "
             msg += f"'{self.tag}' tag."
             raise errors.TemplateRenderingError(msg, self.token) from err
         if cond.negated:
@@ -577,14 +579,14 @@ class CycleNode(Node):
         try:
             tag, arg = token.text.split(None, 1)
         except:
-            msg = f"Malformed 'cycle' tag."
+            msg = "Malformed 'cycle' tag."
             raise errors.TemplateSyntaxError(msg, token) from None
         self.expr = Expression(arg, token)
 
     def wrender(self, context):
         # We store our state info on the context object to avoid a threading mess if
         # the template is being simultaneously rendered by multiple threads.
-        if not self in context.stash:
+        if self not in context.stash:
             items = self.expr.eval(context)
             if not hasattr(items, "__iter__"):
                 items = ""
@@ -620,9 +622,7 @@ class IncludeNode(Node):
                     name, expr = chunk.split("=", 1)
                     self.variables[name.strip()] = Expression(expr.strip(), token)
                 except:
-                    raise errors.TemplateSyntaxError(
-                        "Malformed 'include' tag.", token
-                    ) from None
+                    raise errors.TemplateSyntaxError("Malformed 'include' tag.", token) from None
         else:
             raise errors.TemplateSyntaxError("Malformed 'include' tag.", token)
 
@@ -637,25 +637,27 @@ class IncludeNode(Node):
                 visitor(context, template.root_node)
                 context.pop()
             else:
-                msg = f"No template loader has been specified. "
-                msg += f"A template loader is required by the 'include' tag in "
+                msg = "No template loader has been specified. "
+                msg += "A template loader is required by the 'include' tag in "
                 msg += f"template '{self.token.template_id}', line {self.token.line_number}."
                 raise errors.TemplateLoadError(msg)
         else:
-            msg = f"Invalid argument for the 'include' tag. "
+            msg = "Invalid argument for the 'include' tag. "
             msg += f"The variable '{self.template_arg}' should evaluate to a string. "
             msg += f"This variable has the value: {repr(template_name)}."
             raise errors.TemplateRenderingError(msg, self.token)
-        
+
     def wrender(self, context):
         output = []
         self.visit_node(context, lambda ctx, node: output.append(node.render(ctx)))
         return "".join(output)
-    
+
     def tree_parts(self, context) -> PartsTree:
         output = []
+
         def visitor(ctx, node):
             output.append(node.tree_parts(ctx))
+
         self.visit_node(context, visitor)
         return output[0]
 
@@ -672,9 +674,7 @@ class ExtendsNode(Node):
         try:
             tag, arg = token.text.split(None, 1)
         except:
-            raise errors.TemplateSyntaxError(
-                "Malformed 'extends' tag.", token
-            ) from None
+            raise errors.TemplateSyntaxError("Malformed 'extends' tag.", token) from None
 
         expr = Expression(arg, token)
         if expr.is_literal and isinstance(expr.literal, str):
@@ -744,9 +744,7 @@ class WithNode(Node):
                 name, expr = chunk.split("=", 1)
                 self.variables[name.strip()] = Expression(expr.strip(), token)
             except:
-                raise errors.TemplateSyntaxError(
-                    "Malformed 'with' tag.", token
-                ) from None
+                raise errors.TemplateSyntaxError("Malformed 'with' tag.", token) from None
 
     def wrender(self, context):
         context.push()

pyview/vendor/ibis/template.py

@@ -1,6 +1,7 @@
 from pyview.vendor import ibis
+
 from .context import Context
-from .nodes import ExtendsNode, BlockNode
+from .nodes import BlockNode, ExtendsNode
 
 
 # A Template object is initialized with a template string containing template markup and a
@@ -35,14 +36,12 @@ class Template:
 
     def _render(self, context):
         context.templates.append(self)
-        if self.root_node.children and isinstance(
-            self.root_node.children[0], ExtendsNode
-        ):
+        if self.root_node.children and isinstance(self.root_node.children[0], ExtendsNode):
             if ibis.loader:
                 parent_template = ibis.loader(self.root_node.children[0].parent_name)
                 return parent_template._render(context)
             else:
-                msg = f"No template loader has been specified. A template loader is required "
+                msg = "No template loader has been specified. A template loader is required "
                 msg += f"by the 'extends' tag in template '{self.template_id}'."
                 raise ibis.errors.TemplateLoadError(msg)
         else:

pyview/vendor/ibis/tree.py

@@ -1,7 +1,10 @@
 from dataclasses import dataclass, field
-from typing import Any, Union
+from typing import TYPE_CHECKING, Any, Union
 
-Part = Union[str, "PartsTree", "PartsComprehension"]
+if TYPE_CHECKING:
+    from pyview.stream import Stream
+
+Part = Union[str, "PartsTree", "PartsComprehension", "StreamComprehension"]
 
 
 @dataclass
@@ -33,6 +36,59 @@ class PartsComprehension:
         }
 
 
+@dataclass
+class StreamComprehension:
+    """
+    A comprehension that includes stream metadata for the wire format.
+
+    This is returned by ForNode.tree_parts() when iterating over a Stream.
+    It produces the same {"s": [...], "d": [...]} format as PartsComprehension,
+    but also includes a "stream" key with the stream operations.
+    """
+
+    parts: list["PartsTree"]
+    stream: "Stream"
+
+    def render_parts(self) -> Union[dict[str, Any], str]:
+        # Import here to avoid circular imports
+
+        # Handle empty stream
+        if len(self.parts) == 0:
+            # Still need to check for delete/reset operations
+            ops = self.stream._get_pending_ops()
+            if ops is None:
+                return ""
+            return {"stream": self.stream._to_wire_format(ops)}
+
+        if len(self.parts) == 1:
+            if isinstance(self.parts[0], PartsTree) and self.parts[0].is_empty():
+                # Check for delete/reset operations even with empty parts
+                ops = self.stream._get_pending_ops()
+                if ops is None:
+                    return ""
+                return {"stream": self.stream._to_wire_format(ops)}
+
+        def render(p: Part) -> Any:
+            if isinstance(p, str):
+                return p
+            return p.render_parts()
+
+        statics = self.parts[0].statics
+        dynamics = [[render(d) for d in p.dynamics] for p in self.parts]
+
+        result: dict[str, Any] = {
+            "s": statics,
+            "d": dynamics,
+        }
+
+        # Add stream metadata
+        ops = self.stream._get_pending_ops()
+        if ops is not None:
+            result["stream"] = self.stream._to_wire_format(ops)
+
+        return result
+
+
 @dataclass
 class PartsTree:
     statics: list[str] = field(default_factory=list)
@@ -41,12 +97,15 @@ class PartsTree:
     def add_static(self, s: str):
         self.statics.append(s)
 
-    def add_dynamic(self, d: Union[Part, list[Part]]):
+    def add_dynamic(self, d: Union[Part, list[Part], StreamComprehension]):
         if len(self.statics) < len(self.dynamics) + 1:
             self.statics.append("")
 
         if isinstance(d, str):
             self.dynamics.append(d)
+        elif isinstance(d, StreamComprehension):
+            # StreamComprehension is added directly (not wrapped)
+            self.dynamics.append(d)
         elif isinstance(d, list):
             self.dynamics.append(PartsComprehension(d))
         else:

pyview/vendor/ibis/utils.py

@@ -3,7 +3,6 @@ import re
 
 # Splits a string on instances of a delimiter character. Ignores quoted delimiters.
 def splitc(s, delimiter, strip=False, discard_empty=False, maxsplit=-1):
-
     tokens, buf, expecting, escaped = [], [], None, False
 
     for index, char in enumerate(s):
@@ -13,18 +12,18 @@ def splitc(s, delimiter, strip=False, discard_empty=False, maxsplit=-1):
                 expecting = None
         else:
             if char == delimiter:
-                tokens.append(''.join(buf))
+                tokens.append("".join(buf))
                 buf = []
                 if len(tokens) == maxsplit:
-                    buf.append(s[index+1:])
+                    buf.append(s[index + 1 :])
                     break
             else:
                 buf.append(char)
                 if char in ('"', "'"):
                     expecting = char
-        escaped = not escaped if char == '\\' else False
+        escaped = not escaped if char == "\\" else False
 
-    tokens.append(''.join(buf))
+    tokens.append("".join(buf))
 
     if strip:
         tokens = [t.strip() for t in tokens]
@@ -49,20 +48,20 @@ def splitws(s, maxsplit=-1):
             if char.isspace():
                 if wsrun:
                     continue
-                tokens.append(''.join(buf))
+                tokens.append("".join(buf))
                 buf = []
                 wsrun = True
                 if len(tokens) == maxsplit:
-                    buf.append(s[index+1:].lstrip())
+                    buf.append(s[index + 1 :].lstrip())
                     break
             else:
                 buf.append(char)
                 wsrun = False
                 if char in ('"', "'"):
                     expecting = char
-        escaped = not escaped if char == '\\' else False
+        escaped = not escaped if char == "\\" else False
 
-    tokens.append(''.join(buf))
+    tokens.append("".join(buf))
     return tokens
 
 
@@ -71,22 +70,22 @@ def splitre(s, delimiters, keep_delimiters=False):
     tokens, buf = [], []
     end_last_match = 0
 
-    pattern = r'''"(?:[^\\"]|\\.)*"|'(?:[^\\']|\\.)*'|%s'''
-    pattern %= '|'.join(delimiters)
+    pattern = r""""(?:[^\\"]|\\.)*"|'(?:[^\\']|\\.)*'|%s"""
+    pattern %= "|".join(delimiters)
 
     for match in re.finditer(pattern, s):
         if match.group()[0] in ["'", '"']:
-            buf.append(s[end_last_match:match.end()])
+            buf.append(s[end_last_match : match.end()])
             end_last_match = match.end()
             continue
-        buf.append(s[end_last_match:match.start()])
-        tokens.append(''.join(buf))
+        buf.append(s[end_last_match : match.start()])
+        tokens.append("".join(buf))
         buf = []
         end_last_match = match.end()
         if keep_delimiters:
             tokens.append(match.group())
 
     buf.append(s[end_last_match:])
-    tokens.append(''.join(buf))
+    tokens.append("".join(buf))
 
     return tokens