prefig 0.2.15.dev20250514053750__py3-none-any.whl → 0.5.6.dev20260130060411__py3-none-any.whl

prefig/core/rectangle.py

@@ -71,10 +71,15 @@ def rectangle(element, diagram, parent, outline_status):
     path.set('d', ' '.join(cmds))
 
     if diagram.output_format() == 'tactile':
-        if element.get('stroke') is not None:
+        stroke = element.get('stroke')
+        fill   = element.get('fill')
+        if stroke is not None and stroke != 'none':
             element.set('stroke', 'black')
-        if element.get('fill') is not None:
-            element.set('fill', 'lightgray')
+        if fill is not None:
+            if fill.strip().lower() != 'none':
+                element.set('fill', 'lightgray')
+            else:
+                element.set('fill', 'none')
     else:
         util.set_attr(element, 'stroke', 'none')
         util.set_attr(element, 'fill', 'none')
@@ -97,5 +102,6 @@ def finish_outline(element, diagram, parent):
     diagram.finish_outline(element,
                            element.get('stroke'),
                            element.get('thickness'),
-                           element.get('fill', 'none'),
+#                           element.get('fill', 'none'),
+                           'none',
                            parent)

prefig/core/repeat.py

@@ -2,6 +2,7 @@ import lxml.etree as ET
 import logging
 from . import user_namespace as un
 import copy
+import re
 import numpy as np
 from . import group
 from . import label
@@ -9,6 +10,25 @@ from . import utilities
 
 log = logging.getLogger('prefigure')
 
+# EPUB restricts the characters that can appear in an id to
+#   a-z|A-Z|0-9|_|-
+# This is an issue here since <repeat> elements can create id's
+# This regular expression checks characters to see if they are allowed
+epub_check = re.compile(r'[A-Za-z0-9_-]')
+
+# We also define substitutions for the most common disallowed characters
+epub_dict = {'(': 'p',
+             ')': 'q',
+             '[': 'p',
+             ']': 'q',
+             '{': 'p',
+             '}': 'q',
+             ',': 'c',
+             '.': 'd',
+             '=': '_',
+             r'#': 'h'}
+
+
 # Allows a block of XML to repeat with a changing parameter
 
 def repeat(element, diagram, parent, outline_status):
@@ -40,7 +60,10 @@ def repeat(element, diagram, parent, outline_status):
     if outline is not None:
         element.set('outline', outline)
     if id is not None:
+        if not id.startswith('pf__'):
+            id = 'pf__' + id
         element.set('id', id)
+        element_cp.set('id', id)
 
     for num, k in enumerate(iterator):
         if isinstance(k, np.ndarray):
@@ -48,11 +71,12 @@ def repeat(element, diagram, parent, outline_status):
         else:
             k_str = str(k)
 
-        un.enter_namespace(k_str, k)
+        k_str_clean = epub_clean(k_str)
+        # This is a change since we use the syntax "var_str" for the id suffix
         if count:
-            suffix_str = var + "=" + k_str
+            suffix_str = var + "_" + k_str_clean
         else:
-            suffix_str = var + "=" + str(num)
+            suffix_str = var + "_" + str(num)
 
         definition = ET.SubElement(element, 'definition')
         definition.text = var + '=' + k_str
@@ -78,3 +102,13 @@ def repeat(element, diagram, parent, outline_status):
 
     if annotation is not None:
         diagram.pop_from_annotation_branch()
+
+def epub_clean(s):
+    epub_clean = [bool(epub_check.fullmatch(ch)) for ch in s]
+    chars = []
+    for index, ch in enumerate(s):
+        if epub_clean[index]:
+            chars.append(ch)
+            continue
+        chars.append(epub_dict.get(ch, '_'))
+    return "".join(chars)

prefig/core/shape.py

@@ -36,7 +36,10 @@ def define(element, diagram, parent, outline_status):
             log.error(f"In <define-shapes>, {child.tag} does not define a shape")
             continue
         if child.get('at', None) is not None:
-            child.set('id', child.get('at'))
+            id = child.get('at')
+            if not id.startswith('pf__'):
+                id = 'pf__' + id
+            child.set('id', id)
         dummy_parent = ET.Element('group')
         # this is kind of a hack, but we only need to construct the shape
         # so we stash the format temporarily in case we're building a
@@ -69,6 +72,12 @@ def shape(element, diagram, parent, outline_status):
             return
 
     shape_refs = [r.strip() for r in reference.split(',')]
+    shape_edit = []
+    for shape_ref in shape_refs:
+        if not shape_ref.startswith('pf__'):
+            shape_ref = 'pf__' + shape_ref
+        shape_edit.append(shape_ref)
+    shape_refs = shape_edit
     shapes = []
     for ref in shape_refs:
         shapes.append(diagram.recall_shape(ref))
@@ -82,6 +91,8 @@ def shape(element, diagram, parent, outline_status):
             operation = 'union'
         else:
             path = ET.SubElement(parent, 'use')
+            if not reference.startswith('pf__'):
+                reference = 'pf__' + reference
             path.set('href', r'#' + reference)
 
     if operation is not None:

prefig/core/slope_field.py

@@ -8,8 +8,10 @@ from . import utilities
 from . import grid_axes
 from . import group
 from . import math_utilities as math_util
+from . import calculus
 
 log = logging.getLogger('prefigure')
+np.seterr(divide="ignore", invalid="ignore")
 
 # Add a graphical element for slope fields
 def slope_field(element, diagram, parent, outline_status):
@@ -24,6 +26,8 @@ def slope_field(element, diagram, parent, outline_status):
         return
     bbox = diagram.bbox()
 
+    if element.get('id', None) is None:
+        diagram.add_id(element, None)
     # We're going to turn this element into a group and add lines to it
     element.tag = "group"
     if element.get('outline', 'no') == 'yes':
@@ -112,3 +116,141 @@ def slope_field(element, diagram, parent, outline_status):
 
     group.group(element, diagram, parent, outline_status)
 
+# Add a graphical element for slope fields
+def vector_field(element, diagram, parent, outline_status):
+    if outline_status == 'finish_outline':
+        finish_outline(element, diagram, parent)
+        return
+
+    try:
+        f = un.valid_eval(element.get('function'))
+    except:
+        log.error(f"Error retrieving slope-field function={element.get('function')}")
+        return
+    bbox = diagram.bbox()
+
+    if element.get('id', None) is None:
+        diagram.add_id(element, None)
+
+    # We're going to turn this element into a group and add lines to it
+    element.tag = "group"
+    if element.get('outline', 'no') == 'yes':
+        element.set('outline', 'always')
+
+    # Now we'll construct a line with all the graphical information
+    # and make copies of it
+    line_template = ET.Element('line')
+
+    if diagram.output_format() == 'tactile':
+        line_template.set('stroke', 'black')
+    else:
+        line_template.set('stroke', element.get('stroke', 'blue'))
+    line_template.set('thickness', element.get('thickness', '2'))
+    line_template.set('arrows', '1')
+
+    if element.get('arrow-width', None) is not None:
+        line_template.set('arrow-width', element.get('arrow-width'))
+    if element.get('arrow-angles', None) is not None:
+        line_template.set('arrow-angles', element.get('arrow-angles'))
+
+    field_data = []
+    if element.get('curve', None) is not None:
+        curve = un.valid_eval(element.get('curve'))
+        try:
+            domain = un.valid_eval(element.get('domain'))
+        except:
+            log.error('A @domain is needed if adding a vector field to a curve')
+            return
+        try:
+            N = un.valid_eval(element.get('N'))
+        except:
+            log.error('A @N is needed if adding a vector field to a curve')
+            return
+
+        t = domain[0]
+        # if "f" a function of t or (x,y)?
+        one_variable = True
+        try:
+            f(t)
+        except TypeError:
+            one_variable = False
+
+        dt = (domain[1]-domain[0])/(N-1)
+        for _ in range(N):
+            position = curve(t)
+            if one_variable:
+                field_data.append([position, f(t)])
+            else:
+                field_data.append([position, f(*position)])
+            t += dt
+        scale_factor = un.valid_eval(element.get('scale', '1'))
+
+    else:
+        spacings = element.get('spacings', None)
+        if spacings is not None:
+            try:
+                spacings = un.valid_eval(spacings)
+                rx, ry = spacings
+            except:
+                log.error(f"Error parsing slope-field attribute @spacings={element.get('spacings')}")
+                return
+        else:
+            rx = grid_axes.find_gridspacing((bbox[0], bbox[2]))
+            ry = grid_axes.find_gridspacing((bbox[1], bbox[3]))
+
+        # we will go through and generate the vectors first
+        # since we'll need to scale them
+        max_scale = 0
+        exponent = un.valid_eval(element.get('exponent', '1'))
+        x = rx[0]
+        while x <= rx[2]:
+            y = ry[0]
+            while y <= ry[2]:
+                f_value = f(x, y)
+                if any(np.isnan(f_value)):
+                    y += ry[1]
+                    continue
+
+                try:
+                    if len(f_value) != 2:
+                        log.error("Only two-dimensional vector fields are supported")
+                        return;
+                except:
+                    pass
+                norm = math_util.length(f_value)
+                if norm < 1e-10:
+                    f_value = np.array((0,0))
+                else:
+                    # we will scale the length by length**exponent
+                    # to promote the length of shorter vectors
+                    f_value = norm**exponent * (1/norm * f_value)
+                max_scale = max(max_scale,
+                                abs((f_value[0])/rx[1]),
+                                abs((f_value[1])/ry[1]))
+                field_data.append([np.array([x,y]), f_value])
+                y += ry[1]
+            x += rx[1]
+
+        scale_factor = min(1, 0.75 / max_scale)
+        if element.get('scale') is not None:
+            scale = un.valid_eval(element.get('scale'))
+            scale_factor = scale
+
+    for datum in field_data:
+        p, v = datum
+        v = scale_factor * v
+        # is this long enough to add?
+        tail = p
+        tip  = p+v
+        p0 = diagram.transform(tail)
+        p1 = diagram.transform(tip)
+        if math_util.distance(p0, p1) < 2:
+            continue
+
+        line_el = copy.deepcopy(line_template)
+        line_el.set('p1', utilities.pt2long_str(tail, spacer=','))
+        line_el.set('p2', utilities.pt2long_str(tip, spacer=','))
+        element.append(line_el)
+
+    group.group(element, diagram, parent, outline_status)
+

prefig/core/tags.py

@@ -2,6 +2,7 @@ import logging
 import lxml.etree as ET
 from . import annotations
 from . import area
+from . import axes
 from . import clip
 from . import circle
 from . import coordinates
@@ -10,6 +11,7 @@ from . import definition
 from . import graph
 from . import grid_axes
 from . import group
+from . import image
 from . import implicit
 from . import label
 from . import legend
@@ -36,10 +38,11 @@ tag_dict = {
     'arc': circle.arc,
     'area-between-curves': area.area_between_curves,
     'area-under-curve': area.area_under_curve,
-    'axes': grid_axes.axes,
+    'axes': axes.axes,
     'caption': label.caption,
     'circle': circle.circle,
     'clip': clip.clip,
+    'contour': implicit.implicit_curve,
     'coordinates': coordinates.coordinates,
     'definition': definition.definition,
     'derivative': definition.derivative,
@@ -49,6 +52,7 @@ tag_dict = {
     'grid-axes': grid_axes.grid_axes,
     'group': group.group,
     'histogram': statistics.histogram,
+    'image': image.image,
     'implicit-curve': implicit.implicit_curve,
     'label': label.label,
     'legend': legend.legend,
@@ -61,6 +65,7 @@ tag_dict = {
     'rectangle': rectangle.rectangle,
     'repeat': repeat.repeat,
     'riemann-sum': riemann_sum.riemann_sum,
+    'tick-mark': axes.tick_mark,
     'transform': CTM.transform_group,
     'rotate': CTM.transform_rotate,
     'scale': CTM.transform_scale,
@@ -70,7 +75,8 @@ tag_dict = {
     'tangent-line': tangent_line.tangent,
     'translate': CTM.transform_translate,
     'triangle': polygon.triangle,
-    'vector': vector.vector
+    'vector': vector.vector,
+    'vector-field': slope_field.vector_field
 }
 
 log = logging.getLogger('prefigure')

prefig/core/tangent_line.py

@@ -1,4 +1,6 @@
 import logging
+import lxml.etree as ET
+import numpy as np
 from . import user_namespace as un
 from . import utilities as util
 from . import calculus
@@ -31,6 +33,10 @@ def tangent(element, diagram, parent, outline_status):
     def tangent(x):
         return y0 + m*(x-a)
 
+    name = element.get('name', None)
+    if name is not None:
+        un.enter_namespace(name, tangent)
+
     # determine the interval over which we'll draw the tangent line
     bbox = diagram.bbox()
     domain = element.get('domain', None)
@@ -39,19 +45,38 @@ def tangent(element, diagram, parent, outline_status):
     else: 
         domain = un.valid_eval(domain)
 
-    # find the endpoints of the tangent line
+    scales = diagram.get_scales()
     x1, x2 = domain
-    y1 = tangent(x1)
-    y2 = tangent(x2)
-    p1 = (x1, y1)
-    p2 = (x2, y2)
-    if element.get('infinite') == 'yes' or element.get('domain') is None:
-        p1, p2 = line.infinite_line(p1, p2, diagram)
-    if p1 is None:
-        return
+    if scales[0] == 'linear' and scales[1] == 'linear':
+        # find the endpoints of the tangent line
+        y1 = tangent(x1)
+        y2 = tangent(x2)
+        p1 = (x1, y1)
+        p2 = (x2, y2)
+        if element.get('infinite') == 'yes' or element.get('domain') is None:
+            p1, p2 = line.infinite_line(p1, p2, diagram)
+        if p1 is None:
+            return
 
-    # construct the graphical line element from those points and attributes
-    line_el = line.mk_line(p1, p2, diagram, element.get('id'))
+        # construct the graphical line element from those points and attributes
+        line_el = line.mk_line(p1, p2, diagram, element.get('id'))
+
+    else:
+        line_el = ET.Element('path')
+        if scales[0] == 'log':
+            x_positions = np.logspace(np.log10(x1), np.log(x2), 101)
+        else:
+            x_positions = np.linspace(x1, x2, 101)
+        cmds = []
+        next_cmd = 'M'
+        for x in x_positions:
+            y = tangent(x)
+            if y < 0 and scales[1] == 'log':
+                next_cmd = 'M'
+                continue
+            cmds += [next_cmd, util.pt2str(diagram.transform((x, y)))]
+            next_cmd = 'L'
+        line_el.set('d', ' '.join(cmds))
 
     if diagram.output_format() == 'tactile':
         element.set('stroke', 'black')
@@ -60,7 +85,6 @@ def tangent(element, diagram, parent, outline_status):
     util.set_attr(element, 'thickness', '2')
 
     util.add_attr(line_el, util.get_1d_attr(element))
-#    line_el.set('type', 'tangent line')
     element.set('cliptobbox', 'yes')
     util.cliptobbox(line_el, element, diagram)
 

prefig/core/user_namespace.py

@@ -24,6 +24,7 @@ __delta_on = False
 functions = {x for x in dir(math) + dir(math_utilities) if not "__" in x}.difference({'e', 'pi'})
 functions.add('max')
 functions.add('min')
+functions.add('round')
 variables = {'e', 'pi', 'inf'}
 
 # Transforms an AST by wrapping any List or Tuple inside a numpy array
@@ -66,6 +67,8 @@ def validate_node(node, args=None):
         return True
     if isinstance(node, ast.Expression):
         return validate_node(node.body, args)
+    if isinstance(node, ast.Starred):
+        return validate_node(node.value)
     if isinstance(node, ast.Name):
         if node.id in variables:
             return True
@@ -170,6 +173,11 @@ def derivative(f, name):
     functions.add(name)
     variables.add(name)
 
+def enter_function(name, f):
+    globals()[name] = f
+    functions.add(name)
+    variables.add(name)
+
 def enter_namespace(name, value):
     globals()[name] = value
     variables.add(name)

prefig/core/utilities.py

@@ -2,6 +2,14 @@ import numpy as np
 from . import user_namespace as un
 from . import label
 
+import logging
+logger = logging.getLogger('prefigure')
+
+import warnings
+with warnings.catch_warnings():
+    warnings.filterwarnings('ignore', 'legacy print')
+    np.set_printoptions(legacy="1.25")
+
 colors = {'gray': r'#777', 'lightgray': r'#ccc', 'darkgray': r'#333'}
 
 # Some utilities to handle XML elements
@@ -20,7 +28,7 @@ def get_attr(element, attr, default):
     try:
         attribute = un.valid_eval(element.get(attr, default))
         if isinstance(attribute, np.ndarray):
-            return np.array2string(attribute, separator=',')
+            return ','.join([float2longstr(a) for a in attribute])
         return str(attribute)
     except (TypeError, SyntaxError):  # this is a string that's not in the namespace
         return element.get(attr, default)

prefig/engine.py

@@ -40,7 +40,7 @@ def build(
 ):
     pub_requested = not ignore_publication and publication is not None
     path = Path(filename)
-    if path.suffix != '.xml':
+    if path.suffix == '':
         filename = str(path.parent / (path.stem + '.xml'))
 
     # We're going to look for a publication, possibly in a parent directory
@@ -84,20 +84,40 @@ def build(
 def build_from_string(format, input_string, environment="pyodide"):
     tree = ET.fromstring(input_string)
     log.setLevel(logging.DEBUG)
-    diagrams = tree.xpath('//diagram')
-    if len(diagrams) > 0:
-        output_string = core.parse.mk_diagram(
-            diagrams[0],
-            format,
-            None,     # publication file
-            "prefig", # filename needed for label generation
-            False,    # supress caption
-            None,     # diagram number
-            environment,
-            return_string = True
-        )
-        return output_string
-    return ''
+    ns = {'pf': 'https://prefigure.org'}
+    diagrams_with_ns = tree.xpath('//pf:diagram', namespaces=ns)
+    diagrams_without_ns = tree.xpath('//diagram', namespaces=ns)
+    diagrams = diagrams_with_ns + diagrams_without_ns
+
+    try:
+        diagram = diagrams[0]
+    except:
+        return ''
+
+    # put all elements in default namespace
+    for elem in diagram.getiterator():
+        # Skip comments and processing instructions,
+        # because they do not have names
+        if not (
+                isinstance(elem, ET._Comment)
+                or isinstance(elem, ET._ProcessingInstruction)
+        ):
+            # Remove a namespace URI in the element's name
+            elem.tag = ET.QName(elem).localname
+
+    core.parse.check_duplicate_handles(diagram, set())
+
+    output_string = core.parse.mk_diagram(
+        diagram,
+        format,
+        None,     # publication file
+        "prefig", # filename needed for label generation
+        False,    # supress caption
+        None,     # diagram number
+        environment,
+        return_string = True
+    )
+    return output_string
 
 def pdf(
         format,
@@ -121,23 +141,35 @@ def pdf(
         filename = Path(filename)
     
     if filename.suffix != '.svg':
-        filename = filename.parent / (filename.name + '.svg')
+        filename = filename.parent / (filename.stem + '.svg')
 
     if build_path is None:
         filename_str = str(filename)
-        for dir, dirs, files in os.walk(os.getcwd()):
-            files = set(files)
-            if filename_str in files:
-                build_path = dir / filename
+
+        # fist look in current directory
+        cwd_files = os.listdir('.')
+        if filename_str in cwd_files:
+            build_path = filename
+        else:
+            if 'output' in cwd_files:
+                output_files = os.listdir('output')
+                if filename_str in output_files:
+                    build_path = 'output' / filename
+
+        if build_path is None:
+            for dir, dirs, files in os.walk(os.getcwd()):
+                files = set(files)
+                if filename_str in files:
+                    build_path = dir / filename
         if build_path is None:
-            log.debug(f"Unable to find {filename}")
+            log.error(f"Unable to find {filename}")
             return
 
     dpi = str(dpi)
     executable = shutil.which('rsvg-convert')
     if executable is None:
-        log.debug("rsvg-convert is required to create PDFs.")
-        log.debug("See the installation instructions at https://prefigure.org")
+        log.error("rsvg-convert is required to create PDFs.")
+        log.error("See the installation instructions at https://prefigure.org")
         return
     
     log.info(f"Converting {build_path} to PDF")
@@ -184,12 +216,25 @@ def png(
 
     if build_path is None:
         filename_str = str(filename)
-        for dir, dirs, files in os.walk(os.getcwd()):
-            files = set(files)
-            if filename_str in files:
-                build_path = dir / filename
+        # look first in current directory
+        cwd_files = os.listdir('.')
+        if filename_str in cwd_files:
+            build_path = filename
+        else:
+            # now look in output
+            if 'output' in cwd_files:
+                output_files = os.listdir('output')
+                if filename_str in output_files:
+                    build_path = 'output' / filename
+
+        # we still haven't found it so descend in the file system
+        if build_path is None:
+            for dir, dirs, files in os.walk(os.getcwd()):
+                files = set(files)
+                if filename_str in files:
+                    build_path = dir / filename
         if build_path is None:
-            log.debug(f"Unable to find {filename}")
+            log.error(f"Unable to find {filename}")
             return
 
     log.info(f"Converting {build_path} to PDF")