Fix inconsistent malformed-transform handling (with strict=True opt-in)

setup.cfg

@@ -2,4 +2,7 @@
 universal = 1
 
 [metadata]
-license_file = LICENSE.txt
+license_file = LICENSE.txt
+
+[pydocstyle]
+convention = pep257

setup.py

@@ -3,7 +3,7 @@
 import os
 
 
-VERSION = '1.7.5'
+VERSION = '1.8.0'
 AUTHOR_NAME = 'Andy Port'
 AUTHOR_EMAIL = 'AndyAPort@gmail.com'
 GITHUB = 'https://github.com/mathandy/svgpathtools'

svgpathtools/__init__.py

@@ -7,7 +7,7 @@
                    is_bezier_path, concatpaths, poly2bez, bpoints2bezier,
                    closest_point_in_path, farthest_point_in_path,
                    path_encloses_pt, bbox2path, polygon, polyline)
-from .parser import parse_path
+from .parser import parse_path, parse_transform, SVGSyntaxWarning
 from .paths2svg import disvg, wsvg, paths2Drawing
 from .polytools import polyroots, polyroots01, rational_limit, real, imag
 from .misctools import hex2rgb, rgb2hex

svgpathtools/document.py

@@ -84,7 +84,8 @@
 
 def flattened_paths(group, group_filter=lambda x: True,
                     path_filter=lambda x: True, path_conversions=CONVERSIONS,
-                    group_search_xpath=SVG_GROUP_TAG):
+                    group_search_xpath=SVG_GROUP_TAG,
+                    strict_transform_parsing=False):
     """Returns the paths inside a group (recursively), expressing the
     paths in the base coordinates.
 
@@ -102,6 +103,10 @@ def flattened_paths(group, group_filter=lambda x: True,
             dictionary will be ignored (including the `path` tag). To
             only convert explicit path elements, pass in
             `path_conversions=CONVERT_ONLY_PATHS`.
+        strict_transform_parsing (bool): If true, a ValueError is
+            raised when a transform attribute contains invalid syntax;
+            by default invalid transform substrings are skipped with
+            an SVGSyntaxWarning.
     """
     if not isinstance(group, Element):
         raise TypeError('Must provide an xml.etree.Element object. '
@@ -123,7 +128,8 @@ def flattened_paths(group, group_filter=lambda x: True,
 
     def new_stack_element(element, last_tf):
         return StackElement(element, last_tf.dot(
-            parse_transform(element.get('transform'))))
+            parse_transform(element.get('transform'),
+                            strict=strict_transform_parsing)))
 
     def get_relevant_children(parent, last_tf):
         children = []
@@ -145,7 +151,8 @@ def get_relevant_children(parent, last_tf):
             for path_elem in filter(path_filter, top.group.iterfind(
                     'svg:'+key, SVG_NAMESPACE)):
                 path_tf = top.transform.dot(
-                    parse_transform(path_elem.get('transform')))
+                    parse_transform(path_elem.get('transform'),
+                                    strict=strict_transform_parsing))
                 path = transform(parse_path(converter(path_elem)), path_tf)
                 path.element = path_elem
                 path.transform = path_tf
@@ -160,12 +167,17 @@ def flattened_paths_from_group(group_to_flatten, root, recursive=True,
                                group_filter=lambda x: True,
                                path_filter=lambda x: True,
                                path_conversions=CONVERSIONS,
-                               group_search_xpath=SVG_GROUP_TAG):
+                               group_search_xpath=SVG_GROUP_TAG,
+                               strict_transform_parsing=False):
     """Flatten all the paths in a specific group.
 
     The paths will be flattened into the 'root' frame. Note that root
     needs to be an ancestor of the group that is being flattened.
-    Otherwise, no paths will be returned."""
+    Otherwise, no paths will be returned.
+
+    If `strict_transform_parsing` is true, a ValueError is raised when
+    a transform attribute contains invalid syntax; by default invalid
+    transform substrings are skipped with an SVGSyntaxWarning."""
 
     if not any(group_to_flatten is descendant for descendant in root.iter()):
         warnings.warn('The requested group_to_flatten is not a '
@@ -226,24 +238,33 @@ def desired_path_filter(x):
         return (id(x) not in ignore_paths) and path_filter(x)
 
     return flattened_paths(root, desired_group_filter, desired_path_filter,
-                           path_conversions, group_search_xpath)
+                           path_conversions, group_search_xpath,
+                           strict_transform_parsing=strict_transform_parsing)
 
 
 class Document:
-    def __init__(self, filepath=None):
-        """A container for a DOM-style SVG document.
+    def __init__(self, filepath=None, strict_transform_parsing=False):
+        """
+        A container for a DOM-style SVG document.
 
-        The `Document` class provides a simple interface to modify and analyze 
-        the path elements in a DOM-style document.  The DOM-style document is 
+        The `Document` class provides a simple interface to modify and analyze
+        the path elements in a DOM-style document.  The DOM-style document is
         parsed into an ElementTree object (stored in the `tree` attribute).
 
         This class provides functions for extracting SVG data into Path objects.
         The output Path objects will be transformed based on their parent groups.
-        
+
         Args:
             filepath (str or file-like): The filepath of the
                 DOM-style object or a file-like object containing it.
+            strict_transform_parsing (bool): If true, a ValueError is
+                raised when a transform attribute containing invalid
+                syntax is parsed (transforms are parsed lazily, by
+                `paths()` and `paths_from_group()`); by default invalid
+                transform substrings are skipped with an
+                SVGSyntaxWarning.
         """
+        self.strict_transform_parsing = strict_transform_parsing
 
         # strings are interpreted as file location everything else is treated as
         # file-like object and passed to the xml parser directly
@@ -259,12 +280,13 @@ def __init__(self, filepath=None):
         self.root = self.tree.getroot()
 
     @classmethod
-    def from_svg_string(cls, svg_string):
+    def from_svg_string(cls, svg_string, strict_transform_parsing=False):
         """Constructor for creating a Document object from a string."""
         # wrap string into StringIO object
         svg_file_obj = StringIO(svg_string)
         # create document from file object
-        return Document(svg_file_obj)
+        return Document(svg_file_obj,
+                        strict_transform_parsing=strict_transform_parsing)
 
     def paths(self, group_filter=lambda x: True,
               path_filter=lambda x: True, path_conversions=CONVERSIONS):
@@ -273,8 +295,9 @@ def paths(self, group_filter=lambda x: True,
         Note that any transform attributes are applied before returning
         the paths.
         """
-        return flattened_paths(self.tree.getroot(), group_filter,
-                               path_filter, path_conversions)
+        return flattened_paths(
+            self.tree.getroot(), group_filter, path_filter, path_conversions,
+            strict_transform_parsing=self.strict_transform_parsing)
 
     def paths_from_group(self, group, recursive=True, group_filter=lambda x: True,
                          path_filter=lambda x: True, path_conversions=CONVERSIONS):
@@ -292,8 +315,10 @@ def paths_from_group(self, group, recursive=True, group_filter=lambda x: True,
             warnings.warn("Could not find the requested group!")
             return []
 
-        return flattened_paths_from_group(group, self.tree.getroot(), recursive,
-                                          group_filter, path_filter, path_conversions)
+        return flattened_paths_from_group(
+            group, self.tree.getroot(), recursive, group_filter, path_filter,
+            path_conversions,
+            strict_transform_parsing=self.strict_transform_parsing)
 
     def add_path(self, path, attribs=None, group=None):
         """Add a new path to the SVG."""

svgpathtools/parser.py

@@ -1,66 +1,102 @@
-"""This submodule contains the path_parse() function used to convert SVG path
-element d-strings into svgpathtools Path objects.
-Note: This file was taken (nearly) as is from the svg.path module (v 2.0)."""
+"""
+Parse SVG path element d-strings into svgpathtools Path objects.
+
+This submodule contains the parse_path() function.  Note: this file was
+taken (nearly) as is from the svg.path module (v 2.0).
+"""
 
 # External dependencies
 from __future__ import division, absolute_import, print_function
+from typing import Optional, Sequence, TYPE_CHECKING
+import math
+import re
 import numpy as np
 import warnings
 
 # Internal dependencies
 from .path import Path
 
+if TYPE_CHECKING:
+    # Imported for type annotations only; no XML is parsed here.
+    from xml.etree.ElementTree import Element
+
+# The SVG number grammar. Stricter than float(), which also accepts
+# e.g. '1_0', 'nan', and non-ASCII digits.  (The one deliberate
+# looseness: '1.' is accepted, though the grammar technically wants a
+# digit after the point.)
+_NUMBER_RE = re.compile(r'[+-]?([0-9]+(\.[0-9]*)?|\.[0-9]+)([eE][+-]?[0-9]+)?\Z')
+
 
-def parse_path(pathdef, current_pos=0j, tree_element=None):
+class SVGSyntaxWarning(UserWarning):
+    """Category for warnings about invalid SVG syntax handled leniently."""
+
+
+def parse_path(pathdef: str, current_pos: complex = 0j,
+               tree_element: Optional['Element'] = None) -> Path:
+    """Convert an SVG path element d-string into a Path object."""
     return Path(pathdef, current_pos=current_pos, tree_element=tree_element)
 
 
-def _check_num_parsed_values(values, allowed):
+def _check_num_parsed_values(values: Sequence[float], allowed: Sequence[int],
+                             transform_substr: str) -> None:
     if not any(num == len(values) for num in allowed):
         if len(allowed) > 1:
-            warnings.warn('Expected one of the following number of values {0}, but found {1} values instead: {2}'
-                          .format(allowed, len(values), values))
+            raise ValueError('Expected one of the following number of values {0}, '
+                             'but found {1} values in {2!r}: {3}'
+                             .format(allowed, len(values), transform_substr, values))
         elif allowed[0] != 1:
-            warnings.warn('Expected {0} values, found {1}: {2}'.format(allowed[0], len(values), values))
+            raise ValueError('Expected {0} values in {1!r}, found {2}: {3}'
+                             .format(allowed[0], transform_substr, len(values), values))
         else:
-            warnings.warn('Expected 1 value, found {0}: {1}'.format(len(values), values))
-        return False
-    return True
+            raise ValueError('Expected 1 value in {0!r}, found {1}: {2}'
+                             .format(transform_substr, len(values), values))
+
 
+def _parse_transform_substr(transform_substr: str) -> np.ndarray:
+    """
+    Convert a single SVG transform substring into a 3x3 matrix.
 
-def _parse_transform_substr(transform_substr):
+    A well-formed transform substring has the form `type(v1 v2 ...)`.
+    Raises a ValueError on invalid transform syntax.
+    """
+    if transform_substr.count('(') != 1:
+        raise ValueError('Invalid SVG transform substring: {0!r}'.format(transform_substr))
 
     type_str, value_str = transform_substr.split('(')
-    value_str = value_str.replace(',', ' ')
-    values = list(map(float, filter(None, value_str.split(' '))))
+    # Any leading commas/whitespace are the separator from the preceding
+    # transform in the list, e.g. 'translate(1), rotate(30)'.
+    type_str = type_str.strip(', \t\n\r')
+    tokens = value_str.replace(',', ' ').split()
+    if not all(_NUMBER_RE.match(t) for t in tokens):
+        raise ValueError('Invalid SVG transform substring: {0!r}'.format(transform_substr))
+    values = [float(t) for t in tokens]
+    # A grammar-valid value can still overflow float, e.g. '1e999'.
+    if not all(math.isfinite(v) for v in values):
+        raise ValueError('Non-finite value in SVG transform substring: {0!r}'.format(transform_substr))
 
     transform = np.identity(3)
-    if 'matrix' in type_str:
-        if not _check_num_parsed_values(values, [6]):
-            return transform
+    if type_str == 'matrix':
+        _check_num_parsed_values(values, [6], transform_substr)
 
         transform[0:2, 0:3] = np.array([values[0:6:2], values[1:6:2]])
 
-    elif 'translate' in transform_substr:
-        if not _check_num_parsed_values(values, [1, 2]):
-            return transform
+    elif type_str == 'translate':
+        _check_num_parsed_values(values, [1, 2], transform_substr)
 
         transform[0, 2] = values[0]
         if len(values) > 1:
             transform[1, 2] = values[1]
 
-    elif 'scale' in transform_substr:
-        if not _check_num_parsed_values(values, [1, 2]):
-            return transform
+    elif type_str == 'scale':
+        _check_num_parsed_values(values, [1, 2], transform_substr)
 
         x_scale = values[0]
         y_scale = values[1] if (len(values) > 1) else x_scale
         transform[0, 0] = x_scale
         transform[1, 1] = y_scale
 
-    elif 'rotate' in transform_substr:
-        if not _check_num_parsed_values(values, [1, 3]):
-            return transform
+    elif type_str == 'rotate':
+        _check_num_parsed_values(values, [1, 3], transform_substr)
 
         angle = values[0] * np.pi / 180.0
         if len(values) == 3:
@@ -76,35 +112,63 @@ def _parse_transform_substr(transform_substr):
 
         transform = tf_offset.dot(tf_rotate).dot(tf_offset_neg)
 
-    elif 'skewX' in transform_substr:
-        if not _check_num_parsed_values(values, [1]):
-            return transform
+    elif type_str == 'skewX':
+        _check_num_parsed_values(values, [1], transform_substr)
 
         transform[0, 1] = np.tan(values[0] * np.pi / 180.0)
 
-    elif 'skewY' in transform_substr:
-        if not _check_num_parsed_values(values, [1]):
-            return transform
+    elif type_str == 'skewY':
+        _check_num_parsed_values(values, [1], transform_substr)
 
         transform[1, 0] = np.tan(values[0] * np.pi / 180.0)
     else:
-        # Return an identity matrix if the type of transform is unknown, and warn the user
-        warnings.warn('Unknown SVG transform type: {0}'.format(type_str))
+        raise ValueError('Unknown SVG transform type: {0}'.format(type_str))
 
     return transform
 
 
-def parse_transform(transform_str):
-    """Converts a valid SVG transformation string into a 3x3 matrix.
-    If the string is empty or null, this returns a 3x3 identity matrix"""
-    if not transform_str:
+def parse_transform(transform_str: Optional[str], strict: bool = False) -> np.ndarray:
+    """
+    Convert a valid SVG transformation string into a 3x3 matrix.
+
+    If the string is empty, null, or 'none', this returns a 3x3
+    identity matrix.  By default each invalid transform substring is
+    skipped (i.e. contributes an identity matrix) with a warning.  If
+    `strict` is true, a ValueError is raised on invalid transform
+    syntax instead.
+
+    The warnings use the SVGSyntaxWarning category, so they can be
+    silenced or escalated selectively, e.g.
+    `warnings.simplefilter('error', SVGSyntaxWarning)`.
+    """
+    if transform_str is None or transform_str == '':
         return np.identity(3)
     elif not isinstance(transform_str, str):
         raise TypeError('Must provide a string to parse')
 
+    # 'none' is valid (SVG 2 / CSS transform syntax) and means no transform.
+    if transform_str.strip() == 'none':
+        return np.identity(3)
+
+    transform_substrs = transform_str.split(')')
+    # Anything after the last ')' (e.g. a stray 'matrix' with no
+    # parentheses) is invalid syntax, not a transform to apply -- but a
+    # trailing list-separator comma is harmless.
+    trailing = transform_substrs.pop()
+    if trailing.strip(', \t\n\r'):
+        if strict:
+            raise ValueError('Invalid SVG transform substring: {0!r}'.format(trailing))
+        warnings.warn('Skipping invalid SVG transform substring: {0!r}'.format(trailing),
+                      SVGSyntaxWarning)
+
     total_transform = np.identity(3)
-    transform_substrs = transform_str.split(')')[:-1]  # Skip the last element, because it should be empty
     for substr in transform_substrs:
-        total_transform = total_transform.dot(_parse_transform_substr(substr))
+        try:
+            total_transform = total_transform.dot(_parse_transform_substr(substr))
+        except ValueError as e:
+            if strict:
+                raise
+            warnings.warn('Skipping invalid SVG transform substring {0!r}: {1}'.format(substr, e),
+                          SVGSyntaxWarning)
 
     return total_transform