add back pypi action new tag condition

return error if Path.point() cannot be computed

.github/workflows/codacy.yml

@@ -0,0 +1,14 @@
+name: Codacy
+
+on: ["push"]
+
+jobs:
+  codacy-analysis-cli:
+    name: Codacy Analysis CLI
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@main
+
+      - name: Run Codacy Analysis CLI
+        uses: codacy/codacy-analysis-cli-action@master

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,65 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: '30 2 * * 3'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'python' ]
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

.github/workflows/github-ci-legacy.yml

@@ -0,0 +1,34 @@
+name: Github CI Unit Testing for Legacy Environments
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    continue-on-error: true
+    strategy:
+      matrix:
+        os: [ubuntu-18.04, macos-10.15, windows-2019]
+        python-version: [2.7, 3.5, 3.6]
+    steps:
+      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+      - uses: actions/checkout@v2
+
+      # configure python
+      - uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      # install deps
+      - name: Install dependencies for ${{ matrix.os }} Python ${{ matrix.python-version }}
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+          pip install scipy
+
+      # find and run all unit tests
+      - name: Run unit tests
+        run: python -m unittest discover test

.github/workflows/github-ci.yml

@@ -0,0 +1,34 @@
+name: Github CI Unit Testing
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    continue-on-error: true
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python-version: [3.7, 3.8, 3.9, "3.10", "3.11"]
+    steps:
+      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+      - uses: actions/checkout@v2
+
+      # configure python
+      - uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      # install deps
+      - name: Install dependencies for ${{ matrix.os }} Python ${{ matrix.python-version }}
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+          pip install scipy
+
+      # find and run all unit tests
+      - name: Run unit tests
+        run: python -m unittest discover test

.github/workflows/publish-on-pypi-test.yml

@@ -0,0 +1,37 @@
+name: Publish to TestPyPI
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  build-n-publish:
+    name: Build and publish to TestPyPI
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@master
+    - name: Set up Python 3
+      uses: actions/setup-python@v1
+      with:
+        python-version: 3
+    - name: Install pypa/build
+      run: >-
+        python -m
+        pip install
+        build
+        --user
+    - name: Build a binary wheel and a source tarball
+      run: >-
+        python -m
+        build
+        --sdist
+        --wheel
+        --outdir dist/
+        .
+    - name: Publish to Test PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        skip_existing: true
+        password: ${{ secrets.TESTPYPI_API_TOKEN }}
+        repository_url: https://test.pypi.org/legacy/

.github/workflows/publish-on-pypi.yml

@@ -0,0 +1,42 @@
+name: Publish to PyPI if new version
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  build-n-publish:
+    name: Build and publish to TestPyPI and PyPI
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@master
+    - name: Set up Python 3
+      uses: actions/setup-python@v1
+      with:
+        python-version: 3
+    - name: Install pypa/build
+      run: >-
+        python -m
+        pip install
+        build
+        --user
+    - name: Build a binary wheel and a source tarball
+      run: >-
+        python -m
+        build
+        --sdist
+        --wheel
+        --outdir dist/
+        .
+    - name: Publish to Test PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        skip_existing: true
+        password: ${{ secrets.TESTPYPI_API_TOKEN }}
+        repository_url: https://test.pypi.org/legacy/
+    - name: Publish to PyPI
+      if: startsWith(github.ref, 'refs/tags')
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        password: ${{ secrets.PYPI_API_TOKEN }}

.gitignore

@@ -5,3 +5,4 @@ build
 svgpathtools.egg-info
 !.travis.yml
 !/.gitignore
+!/.github

.travis.yml

@@ -1,15 +0,0 @@
-language: python
-python:
-- '2.7'
-- '3.6'
-install:
-- pip install numpy svgwrite scipy
-script:
-- python -m unittest discover test
-deploy:
-  provider: pypi
-  username: __token__
-  password:
-    secure: DaP6S0yj9KlXICtYCWkd54f+yulPYMqr01giOFs2xv5kvMHF1GV160XvYdeLDfwLwAsjKr7438vhgeik99T9iWVb9SYQQsOj8zx+uKcNvNxY/+cHxN9joVOMbhowiqELtKbyNSf1fzax8CGv5+L6k7HfiFV6Zxy4r/4a7JJnavqlsyFn2fixD5FmY+gXjMlnWAer3Q9/1GCWhoUEkON9TRVUcZkYvvBGG16A3m/5o9brCiilaNH5lMiHjOQfbEjxYRgIy6wLGOT9u7EwYAhbnzKhqiaR2jQ5ZxFn52CVoy3r8+T9zvVtToDcjdn9bI+CEFiU37FR1sdJhANFozsoVT3LZid97e7BuMa5+UfFZWZIU7SOcPkzOYxEGwrwqrBWfSeQ3/R76fCcVyy4mNh7YJ5q/89y+NbIpWl6LxVJIwkfix9SUv0z1w4jFzOk5anzrCAJKtJxVFZSUC70ERPaDRK3t9jrZZNS9LIh7wcWGHuGyD4h/8gZr9y3STmNImDq1KdJnldgnOefIS2OXwM5IRkxKvtGeWgn123mp/1XoKDGX8ZhoWp0W0y1A9nZtOkWFjTUjmmj8SeD2R98KBQACsTUqTg3jtZR5dh3VHIPvUc2GeMXQVTZJspi9nyDhJbTLluMk+694S1nRb6Qv0UgIcz651gnv4s8qa6lGXKxEEg=
-  on:
-    tags: true

README.ipynb

@@ -4,6 +4,10 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "[![Donate](https://img.shields.io/badge/donate-paypal-brightgreen)](https://www.paypal.com/donate?business=4SKJ27AM4EYYA&no_recurring=0&item_name=Support+the+creator+of+svgpathtools?++He%27s+a+student+and+would+appreciate+it.&currency_code=USD)\n",
+    "![Python](https://img.shields.io/pypi/pyversions/svgpathtools.svg)\n",
+    "[![PyPI](https://img.shields.io/pypi/v/svgpathtools)](https://pypi.org/project/svgpathtools/)\n",
+    "[![PyPI - Downloads](https://img.shields.io/pypi/dm/svgpathtools?color=yellow)](https://pypistats.org/packages/svgpathtools)\n",
     "# svgpathtools\n",
     "\n",
     "svgpathtools is a collection of tools for manipulating and analyzing SVG Path objects and Bézier curves.\n",
@@ -36,25 +40,15 @@
     "## Prerequisites\n",
     "- **numpy**\n",
     "- **svgwrite**\n",
+    "- **scipy** (optional but recommended for performance)\n",
     "\n",
     "## Setup\n",
     "\n",
-    "If not already installed, you can **install the prerequisites** using  pip.\n",
-    "\n",
-    "```bash\n",
-    "$ pip install numpy\n",
-    "```\n",
-    "\n",
-    "```bash\n",
-    "$ pip install svgwrite\n",
-    "```\n",
-    "\n",
-    "Then **install svgpathtools**:\n",
     "```bash\n",
     "$ pip install svgpathtools\n",
     "```  \n",
     "  \n",
-    "### Alternative Setup \n",
+    "### Alternative Setup\n",
     "You can download the source from Github and install by using the command (from inside the folder containing setup.py):\n",
     "\n",
     "```bash\n",

README.md

@@ -1,5 +1,10 @@
+[![Donate](https://img.shields.io/badge/donate-paypal-brightgreen)](https://www.paypal.com/donate?business=4SKJ27AM4EYYA&no_recurring=0&item_name=Support+the+creator+of+svgpathtools?++He%27s+a+student+and+would+appreciate+it.&currency_code=USD)
+![Python](https://img.shields.io/pypi/pyversions/svgpathtools.svg)
+[![PyPI](https://img.shields.io/pypi/v/svgpathtools)](https://pypi.org/project/svgpathtools/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/svgpathtools?color=yellow)](https://pypistats.org/packages/svgpathtools)
 # svgpathtools
 
+
 svgpathtools is a collection of tools for manipulating and analyzing SVG Path objects and Bézier curves.
 
 ## Features
@@ -30,20 +35,10 @@ Some included tools:
 ## Prerequisites
 - **numpy**
 - **svgwrite**
+- **scipy** (optional, but recommended for performance)
 
 ## Setup
 
-If not already installed, you can **install the prerequisites** using  pip.
-
-```bash
-$ pip install numpy
-```
-
-```bash
-$ pip install svgwrite
-```
-
-Then **install svgpathtools**:
 ```bash
 $ pip install svgpathtools
 ```  

SECURITY.md

@@ -0,0 +1,5 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+To report any security vulnerability, email andyaport@gmail.com

donate-button.svg

@@ -0,0 +1,16 @@
+<?xml version="1.0" ?>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:ev="http://www.w3.org/2001/xml-events" xmlns:xlink="http://www.w3.org/1999/xlink" baseProfile="full" height="50px" version="1.1" viewBox="-15.075 -5.075 180.15 60.15" width="150px">
+	<defs>
+		<path d="M 10.0,24.0 L 140.0,24.0" id="tp0"/>
+		<path d="M 10.0,40.0 L 140.0,40.0" id="tp1"/>
+	</defs>
+	<a href="https://www.paypal.com/donate?business=4SKJ27AM4EYYA&amp;no_recurring=0&amp;item_name=Support+the+creator+of+svgpathtools?++He%27s+a+student+and+would+appreciate+it.&amp;currency_code=USD">
+		<path d="M 0.0,25.0 C 0.0,0.0 0.0,0.0 75.0,0.0 C 150.0,0.0 150.0,0.0 150.0,25.0 C 150.0,50.0 150.0,50.0 75.0,50.0 C 0.0,50.0 0.0,50.0 0.0,25.0" fill="#34eb86" stroke="#000000" stroke-width="0.15"/>
+		<text font-size="15" font-weight="bold">
+			<textPath startOffset="50%" text-anchor="middle" xlink:href="#tp0">Donate to the creator</textPath>
+		</text>
+		<text font-size="16">
+			<textPath startOffset="50%" text-anchor="middle" xlink:href="#tp1">(He's a student.)</textPath>
+		</text>
+	</a>
+</svg>

examples/compute-many-points-quickly-using-numpy-arrays.py

@@ -8,7 +8,7 @@ Note: The relevant matrix transformation for quadratics can be found in the
 svgpathtools.bezier module."""
 from __future__ import print_function
 import numpy as np
-from svgpathtools import *
+from svgpathtools import bezier_point, Path, bpoints2bezier, polynomial2bezier
 
 
 class HigherOrderBezier:

examples/determine-if-svg-path-is-contained-in-other-path-example.py

@@ -7,7 +7,8 @@ Path.continuous_subpaths() method to split a paths into a list of its
 continuous subpaths.
 """
 
-from svgpathtools import *
+from svgpathtools import Path, Line
+
 
 def path1_is_contained_in_path2(path1, path2):
     assert path2.isclosed()  # This question isn't well-defined otherwise
@@ -16,11 +17,11 @@ def path1_is_contained_in_path2(path1, path2):
 
     # find a point that's definitely outside path2
     xmin, xmax, ymin, ymax = path2.bbox()
-    B = (xmin + 1) + 1j*(ymax + 1)
+    b = (xmin + 1) + 1j*(ymax + 1)
 
-    A = path1.start  # pick an arbitrary point in path1
-    AB_line = Path(Line(A, B))
-    number_of_intersections = len(AB_line.intersect(path2))
+    a = path1.start  # pick an arbitrary point in path1
+    ab_line = Path(Line(a, b))
+    number_of_intersections = len(ab_line.intersect(path2))
     if number_of_intersections % 2:  # if number of intersections is odd
         return True
     else:

examples/distance-between-two-svg-paths-example.py

@@ -1,13 +1,16 @@
-from svgpathtools import *
+from svgpathtools import disvg, Line, CubicBezier
+from scipy.optimize import fminbound
 
 # create some example paths
 path1 = CubicBezier(1,2+3j,3-5j,4+1j)
 path2 = path1.rotated(60).translated(3)
 
-# find minimizer
-from scipy.optimize import fminbound
+
 def dist(t):
 	return path1.radialrange(path2.point(t))[0][0]
+
+
+# find minimizer
 T2 = fminbound(dist, 0, 1)
 
 # Let's do a visual check

examples/wasm-via-pyodide-example.html

@@ -0,0 +1,62 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+	<script src="https://cdn.jsdelivr.net/pyodide/v0.18.1/full/pyodide.js"></script>
+	<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
+	<meta charset="utf-8" />
+	<title>svgpathtools in JS!</title>
+</head>
+
+<body>
+<button id="go_button" onclick="tick()" hidden>Click Me!</button>
+<br />
+<br />
+<div>Output:</div>
+<label for="output"></label>
+<textarea id="output" style="width: 100%;" rows="6" disabled></textarea>
+
+<svg height="100" width="100">
+    <circle cx="50" cy="50" r="40" stroke-width="2" stroke="black" fill="blue"/>
+	<path id="ticker" d="M 50 50 L 50 15" stroke-width="2" stroke="black"/>
+	<circle cx="50" cy="50" r="3" stroke-width="2" stroke="black" fill="green"/>
+	Sorry, your browser does not support inline SVG.
+</svg>
+
+<script>
+	// init Pyodide environment and install svgpathtools
+	async function main() {
+		let pyodide = await loadPyodide({
+			indexURL: "https://cdn.jsdelivr.net/pyodide/v0.18.1/full/",
+		});
+		await pyodide.loadPackage("micropip");
+		pyodide.runPythonAsync(`
+          import micropip
+          await micropip.install('svgpathtools')
+        `);
+		output.value += "svgpathtools is ready!\n";
+		return pyodide;
+	}
+
+	async function tick() {
+		let clock_hand = document.getElementById("ticker");
+		let pyodide = await pyodideReadyPromise;
+		try {
+			let result = pyodide.runPython(`
+			  from svgpathtools import parse_path
+			  parse_path('${clock_hand.getAttribute('d')}').rotated(45, origin=50+50j).d()
+			`);
+			clock_hand.setAttribute('d', result);
+		} catch (err) {
+			output.value += err;
+		}
+	}
+
+	let pyodideReadyPromise = main();
+	$(document).ready(function(){
+		const output = document.getElementById("output");
+		output.value = "Initializing...\n";
+		document.getElementById("go_button").removeAttribute('hidden');
+	});
+</script>
+</body>
+</html>

requirements.txt

@@ -1,2 +1,3 @@
 numpy
 svgwrite
+scipy

setup.py

@@ -3,18 +3,17 @@ import codecs
 import os
 
 
-VERSION = '1.4.1'
+VERSION = '1.6.1'
 AUTHOR_NAME = 'Andy Port'
 AUTHOR_EMAIL = 'AndyAPort@gmail.com'
+GITHUB = 'https://github.com/mathandy/svgpathtools'
+
+_here = os.path.abspath(os.path.dirname(__file__))
 
 
-def read(*parts):
-    """
-    Build an absolute path from *parts* and and return the contents of the
-    resulting file.  Assume UTF-8 encoding.
-    """
-    HERE = os.path.abspath(os.path.dirname(__file__))
-    with codecs.open(os.path.join(HERE, *parts), "rb", "utf-8") as f:
+def read(relative_path):
+    """Reads file at relative path, returning contents as string."""
+    with codecs.open(os.path.join(_here, relative_path), "rb", "utf-8") as f:
         return f.read()
 
 
@@ -27,12 +26,12 @@ setup(name='svgpathtools',
       long_description_content_type='text/markdown',
       author=AUTHOR_NAME,
       author_email=AUTHOR_EMAIL,
-      url='https://github.com/mathandy/svgpathtools',
-      # download_url = 'http://github.com/mathandy/svgpathtools/tarball/'+VERSION,
+      url=GITHUB,
+      download_url='{}/releases/download/{}/svgpathtools-{}-py2.py3-none-any.whl'
+                   ''.format(GITHUB, VERSION, VERSION),
       license='MIT',
-      install_requires=['numpy', 'svgwrite'],
+      install_requires=['numpy', 'svgwrite', 'scipy'],
       platforms="OS Independent",
-      requires=['numpy', 'svgwrite'],
       keywords=['svg', 'svg path', 'svg.path', 'bezier', 'parse svg path', 'display svg'],
       classifiers=[
             "Development Status :: 4 - Beta",
@@ -41,6 +40,14 @@ setup(name='svgpathtools',
             "Operating System :: OS Independent",
             "Programming Language :: Python :: 2",
             "Programming Language :: Python :: 3",
+            "Programming Language :: Python :: 2.7",
+            "Programming Language :: Python :: 3.5",
+            "Programming Language :: Python :: 3.6",
+            "Programming Language :: Python :: 3.7",
+            "Programming Language :: Python :: 3.8",
+            "Programming Language :: Python :: 3.9",
+            "Programming Language :: Python :: 3.10",
+            "Programming Language :: Python :: 3.11",
             "Topic :: Multimedia :: Graphics :: Editors :: Vector-Based",
             "Topic :: Scientific/Engineering",
             "Topic :: Scientific/Engineering :: Image Recognition",

svgpathtools/__init__.py

@@ -17,6 +17,6 @@ from .document import (Document, CONVERSIONS, CONVERT_ONLY_PATHS,
 from .svg_io_sax import SaxDocument
 
 try:
-    from .svg_to_paths import svg2paths, svg2paths2
+    from .svg_to_paths import svg2paths, svg2paths2, svgstr2paths
 except ImportError:
     pass

svgpathtools/document.py

@@ -13,7 +13,7 @@ An Historic Note:
 Example:
     Typical usage looks something like the following.
 
-        >> from svgpathtools import *
+        >> from svgpathtools import Document
         >> doc = Document('my_file.html')
         >> for path in doc.paths():
         >>     # Do something with the transformed Path object.
@@ -41,8 +41,10 @@ import xml.etree.ElementTree as etree
 from xml.etree.ElementTree import Element, SubElement, register_namespace
 from xml.dom.minidom import parseString
 import warnings
+from io import StringIO
 from tempfile import gettempdir
 from time import time
+import numpy as np
 
 # Internal dependencies
 from .parser import parse_path
@@ -50,13 +52,17 @@ from .parser import parse_transform
 from .svg_to_paths import (path2pathd, ellipse2pathd, line2pathd,
                            polyline2pathd, polygon2pathd, rect2pathd)
 from .misctools import open_in_browser
-from .path import *
+from .path import transform, Path, is_path_segment
 
 # To maintain forward/backward compatibility
 try:
-    str = basestring
+    string = basestring
 except NameError:
-    pass
+    string = str
+try:
+    from os import PathLike
+except ImportError:
+    PathLike = string
 
 # Let xml.etree.ElementTree know about the SVG namespace
 SVG_NAMESPACE = {'svg': 'http://www.w3.org/2000/svg'}
@@ -235,13 +241,14 @@ class Document:
         The output Path objects will be transformed based on their parent groups.
         
         Args:
-            filepath (str): The filepath of the DOM-style object.
+            filepath (str or file-like): The filepath of the
+                DOM-style object or a file-like object containing it.
         """
 
-        # remember location of original svg file
-        self.original_filepath = filepath
-        if filepath is not None and os.path.dirname(filepath) == '':
-            self.original_filepath = os.path.join(os.getcwd(), filepath)
+        # strings are interpreted as file location everything else is treated as
+        # file-like object and passed to the xml parser directly
+        from_filepath = isinstance(filepath, string) or isinstance(filepath, PathLike)
+        self.original_filepath = os.path.abspath(filepath) if from_filepath else None
 
         if filepath is None:
             self.tree = etree.ElementTree(Element('svg'))
@@ -251,6 +258,14 @@ class Document:
 
         self.root = self.tree.getroot()
 
+    @classmethod
+    def from_svg_string(cls, svg_string):
+        """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)
+
     def paths(self, group_filter=lambda x: True,
               path_filter=lambda x: True, path_conversions=CONVERSIONS):
         """Returns a list of all paths in the document.
@@ -263,7 +278,7 @@ class Document:
 
     def paths_from_group(self, group, recursive=True, group_filter=lambda x: True,
                          path_filter=lambda x: True, path_conversions=CONVERSIONS):
-        if all(isinstance(s, str) for s in group):
+        if all(isinstance(s, string) for s in group):
             # If we're given a list of strings, assume it represents a
             # nested sequence
             group = self.get_group(group)
@@ -289,7 +304,7 @@ class Document:
 
         # If given a list of strings (one or more), assume it represents
         # a sequence of nested group names
-        elif all(isinstance(elem, str) for elem in group):
+        elif len(group) > 0 and all(isinstance(elem, str) for elem in group):
             group = self.get_or_add_group(group)
 
         elif not isinstance(group, Element):
@@ -308,7 +323,7 @@ class Document:
             path_svg = path.d()
         elif is_path_segment(path):
             path_svg = Path(path).d()
-        elif isinstance(path, str):
+        elif isinstance(path, string):
             # Assume this is a valid d-string.
             # TODO: Should we sanity check the input string?
             path_svg = path

svgpathtools/path.py

@@ -12,12 +12,14 @@ except ImportError:
 from warnings import warn
 from operator import itemgetter
 import numpy as np
+from itertools import tee
+from functools import reduce
 
 # these imports were originally from math and cmath, now are from numpy
 # in order to encourage code that generalizes to vector inputs
 from numpy import sqrt, cos, sin, tan, arccos as acos, arcsin as asin, \
     degrees, radians, log, pi, ceil
-from numpy import exp, sqrt as csqrt, angle as phase
+from numpy import exp, sqrt as csqrt, angle as phase, isnan
 
 try:
     from scipy.integrate import quad
@@ -41,8 +43,8 @@ except NameError:
 COMMANDS = set('MmZzLlHhVvCcSsQqTtAa')
 UPPERCASE = set('MZLHVCSQTA')
 
-COMMAND_RE = re.compile("([MmZzLlHhVvCcSsQqTtAa])")
-FLOAT_RE = re.compile("[-+]?[0-9]*\.?[0-9]+(?:[eE][-+]?[0-9]+)?")
+COMMAND_RE = re.compile(r"([MmZzLlHhVvCcSsQqTtAa])")
+FLOAT_RE = re.compile(r"[-+]?[0-9]*\.?[0-9]+(?:[eE][-+]?[0-9]+)?")
 
 # Default Parameters ##########################################################
 
@@ -78,11 +80,14 @@ _is_smooth_from_warning = \
 
 def bezier_segment(*bpoints):
     if len(bpoints) == 2:
-        return Line(*bpoints)
+        start, end = bpoints
+        return Line(start, end)
     elif len(bpoints) == 4:
-        return CubicBezier(*bpoints)
+        start, control1, control2, end = bpoints
+        return CubicBezier(start, control1, control2, end)
     elif len(bpoints) == 3:
-        return QuadraticBezier(*bpoints)
+        start, control, end = bpoints
+        return QuadraticBezier(start, control, end)
     else:
         assert len(bpoints) in (2, 3, 4)
 
@@ -132,6 +137,7 @@ def polygon(*points):
     return Path(*[Line(points[i], points[(i + 1) % len(points)])
                   for i in range(len(points))])
 
+
 # Conversion###################################################################
 
 def bpoints2bezier(bpoints):
@@ -180,13 +186,22 @@ def bez2poly(bez, numpy_ordering=True, return_poly1d=False):
 
 
 # Geometric####################################################################
+def transform_segments_together(path, transformation):
+    """Makes sure that, if joints were continuous, they're kept that way."""
+    transformed_segs = [transformation(seg) for seg in path]
+
+    for i, (sa, sb) in enumerate(path.joints()):
+        if sa.end == sb.start:
+            transformed_segs[i].end = transformed_segs[(i + 1) % len(path)].start
+    return Path(*transformed_segs)
+
 
 def rotate(curve, degs, origin=None):
     """Returns curve rotated by `degs` degrees (CCW) around the point `origin`
     (a complex number).  By default origin is either `curve.point(0.5)`, or in
     the case that curve is an Arc object, `origin` defaults to `curve.center`.
     """
-    def transform(z):
+    def rotate_point(z):
         return exp(1j*radians(degs))*(z - origin) + origin
 
     if origin is None:
@@ -196,12 +211,13 @@ def rotate(curve, degs, origin=None):
             origin = curve.point(0.5)
 
     if isinstance(curve, Path):
-        return Path(*[rotate(seg, degs, origin=origin) for seg in curve])
+        transformation = lambda seg: rotate(seg, degs, origin=origin)
+        return transform_segments_together(curve, transformation)
     elif is_bezier_segment(curve):
-        return bpoints2bezier([transform(bpt) for bpt in curve.bpoints()])
+        return bpoints2bezier([rotate_point(bpt) for bpt in curve.bpoints()])
     elif isinstance(curve, Arc):
-        new_start = transform(curve.start)
-        new_end = transform(curve.end)
+        new_start = rotate_point(curve.start)
+        new_end = rotate_point(curve.end)
         new_rotation = curve.rotation + degs
         return Arc(new_start, radius=curve.radius, rotation=new_rotation,
                    large_arc=curve.large_arc, sweep=curve.sweep, end=new_end)
@@ -214,7 +230,8 @@ def translate(curve, z0):
     """Shifts the curve by the complex quantity z such that
     translate(curve, z0).point(t) = curve.point(t) + z0"""
     if isinstance(curve, Path):
-        return Path(*[translate(seg, z0) for seg in curve])
+        transformation = lambda seg: translate(seg, z0)
+        return transform_segments_together(curve, transformation)
     elif is_bezier_segment(curve):
         return bpoints2bezier([bpt + z0 for bpt in curve.bpoints()])
     elif isinstance(curve, Arc):
@@ -255,7 +272,8 @@ def scale(curve, sx, sy=None, origin=0j):
         return poly2bez(p)
 
     if isinstance(curve, Path):
-        return Path(*[scale(seg, sx, sy, origin) for seg in curve])
+        transformation = lambda seg: scale(seg, sx, sy, origin)
+        return transform_segments_together(curve, transformation)
     elif is_bezier_segment(curve):
         return scale_bezier(curve)
     elif isinstance(curve, Arc):
@@ -276,6 +294,10 @@ def scale(curve, sx, sy=None, origin=0j):
 
 def transform(curve, tf):
     """Transforms the curve by the homogeneous transformation matrix tf"""
+
+    if all((tf == np.eye(3)).ravel()):
+        return curve  # tf is identity, return curve as is
+
     def to_point(p):
         return np.array([[p.real], [p.imag], [1.0]])
 
@@ -286,20 +308,45 @@ def transform(curve, tf):
         return v.item(0) + 1j * v.item(1)
 
     if isinstance(curve, Path):
-        return Path(*[transform(segment, tf) for segment in curve])
+        transformation = lambda seg: transform(seg, tf)
+        return transform_segments_together(curve, transformation)
+
     elif is_bezier_segment(curve):
         return bpoints2bezier([to_complex(tf.dot(to_point(p)))
                                for p in curve.bpoints()])
     elif isinstance(curve, Arc):
         new_start = to_complex(tf.dot(to_point(curve.start)))
         new_end = to_complex(tf.dot(to_point(curve.end)))
-        new_radius = to_complex(tf.dot(to_vector(curve.radius)))
-        if tf[0][0] * tf[1][1] >= 0.0:
-            new_sweep = curve.sweep
+        
+        # Based on https://math.stackexchange.com/questions/2349726/
+        rx2 = curve.radius.real ** 2
+        ry2 = curve.radius.imag ** 2
+
+        Q = np.array([[1/rx2, 0], [0, 1/ry2]])
+        invT = np.linalg.inv(tf[:2,:2])
+        D = reduce(np.matmul, [invT.T, Q, invT])
+
+        eigvals, eigvecs = np.linalg.eig(D)
+
+        rx = 1 / np.sqrt(eigvals[0])
+        ry = 1 / np.sqrt(eigvals[1])
+
+        new_radius = complex(rx, ry)
+
+        xeigvec = eigvecs[:, 0]
+        rot = np.degrees(np.arccos(xeigvec[0]))
+
+        if new_radius.real == 0 or new_radius.imag == 0 :
+            return Line(new_start, new_end)
         else:
-            new_sweep = not curve.sweep
-        return Arc(new_start, radius=new_radius, rotation=curve.rotation,
-                   large_arc=curve.large_arc, sweep=new_sweep, end=new_end)
+            if tf[0][0] * tf[1][1] >= 0.0:
+                new_sweep = curve.sweep
+            else:
+                new_sweep = not curve.sweep
+            return Arc(new_start, radius=new_radius, rotation=curve.rotation + rot,
+                       large_arc=curve.large_arc, sweep=new_sweep, end=new_end,
+                       autoscale_radius=True)
+
     else:
         raise TypeError("Input `curve` should be a Path, Line, "
                         "QuadraticBezier, CubicBezier, or Arc object.")
@@ -528,8 +575,7 @@ def inv_arclength(curve, s, s_tol=ILENGTH_S_TOL, maxits=ILENGTH_MAXITS,
 
 
 def crop_bezier(seg, t0, t1):
-    """returns a cropped copy of this segment which starts at self.point(t0)
-    and ends at self.point(t1)."""
+    """Crop a copy of this `self` from `self.point(t0)` to `self.point(t1)`."""
     assert t0 < t1
     if t0 == 0:
         cropped_seg = seg.split(t1)[0]
@@ -556,6 +602,9 @@ class Line(object):
         self.start = start
         self.end = end
 
+    def __hash__(self):
+        return hash((self.start, self.end))
+
     def __repr__(self):
         return 'Line(start=%s, end=%s)' % (self.start, self.end)
 
@@ -595,7 +644,7 @@ class Line(object):
 
     def points(self, ts):
         """Faster than running Path.point many times."""
-        return self.poly(ts)
+        return self.poly()(ts)
 
     def length(self, t0=0, t1=1, error=None, min_depth=None):
         """returns the length of the line segment between t0 and t1."""
@@ -666,6 +715,19 @@ class Line(object):
         Note: This will fail if the two segments coincide for more than a
         finite collection of points.
         tol is not used."""
+        if isinstance(other_seg, (Line, QuadraticBezier, CubicBezier)):
+            ob = [e.real for e in other_seg.bpoints()]
+            sb = [e.real for e in self.bpoints()]
+            if min(ob) > max(sb):
+                return []
+            if max(ob) < min(sb):
+                return []
+            ob = [e.imag for e in other_seg.bpoints()]
+            sb = [e.imag for e in self.bpoints()]
+            if min(ob) > max(sb):
+                return []
+            if max(ob) < min(sb):
+                return []
         if isinstance(other_seg, Line):
             assert other_seg.end != other_seg.start and self.end != self.start
             assert self != other_seg
@@ -812,6 +874,9 @@ class QuadraticBezier(object):
         # used to know if self._length needs to be updated
         self._length_info = {'length': None, 'bpoints': None}
 
+    def __hash__(self):
+        return hash((self.start, self.control, self.end))
+
     def __repr__(self):
         return 'QuadraticBezier(start=%s, control=%s, end=%s)' % (
             self.start, self.control, self.end)
@@ -869,7 +934,7 @@ class QuadraticBezier(object):
 
     def points(self, ts):
         """Faster than running Path.point many times."""
-        return self.poly(ts)
+        return self.poly()(ts)
 
     def length(self, t0=0, t1=1, error=None, min_depth=None):
         if t0 == 1 and t1 == 0:
@@ -881,31 +946,30 @@ class QuadraticBezier(object):
 
         if abs(a) < 1e-12:
             s = abs(b)*(t1 - t0)
-        elif abs(a_dot_b + abs(a)*abs(b)) < 1e-12:
-            tstar = abs(b)/(2*abs(a))
-            if t1 < tstar:
-                return abs(a)*(t0**2 - t1**2) - abs(b)*(t0 - t1)
-            elif tstar < t0:
-                return abs(a)*(t1**2 - t0**2) - abs(b)*(t1 - t0)
-            else:
-                return abs(a)*(t1**2 + t0**2) - abs(b)*(t1 + t0) + \
-                    abs(b)**2/(2*abs(a))
         else:
-            c2 = 4*(a.real**2 + a.imag**2)
-            c1 = 4*a_dot_b
-            c0 = b.real**2 + b.imag**2
+            c2 = 4 * (a.real ** 2 + a.imag ** 2)
+            c1 = 4 * a_dot_b
+            c0 = b.real ** 2 + b.imag ** 2
 
-            beta = c1/(2*c2)
-            gamma = c0/c2 - beta**2
+            beta = c1 / (2 * c2)
+            gamma = c0 / c2 - beta ** 2
 
-            dq1_mag = sqrt(c2*t1**2 + c1*t1 + c0)
-            dq0_mag = sqrt(c2*t0**2 + c1*t0 + c0)
-            logarand = (sqrt(c2)*(t1 + beta) + dq1_mag) / \
-                       (sqrt(c2)*(t0 + beta) + dq0_mag)
-
-            s = (t1 + beta)*dq1_mag - (t0 + beta)*dq0_mag + \
-                gamma*sqrt(c2)*log(logarand)
+            dq1_mag = sqrt(c2 * t1 ** 2 + c1 * t1 + c0)
+            dq0_mag = sqrt(c2 * t0 ** 2 + c1 * t0 + c0)
+            logarand = (sqrt(c2) * (t1 + beta) + dq1_mag) / \
+                       (sqrt(c2) * (t0 + beta) + dq0_mag)
+            s = (t1 + beta) * dq1_mag - (t0 + beta) * dq0_mag + \
+                gamma * sqrt(c2) * log(logarand)
             s /= 2
+            if isnan(s):
+                tstar = abs(b) / (2 * abs(a))
+                if t1 < tstar:
+                    return abs(a) * (t0 ** 2 - t1 ** 2) - abs(b) * (t0 - t1)
+                elif tstar < t0:
+                    return abs(a) * (t1 ** 2 - t0 ** 2) - abs(b) * (t1 - t0)
+                else:
+                    return abs(a) * (t1 ** 2 + t0 ** 2) - abs(b) * (t1 + t0) + \
+                           abs(b) ** 2 / (2 * abs(a))
 
         if t0 == 1 and t1 == 0:
             self._length_info['length'] = s
@@ -991,6 +1055,19 @@ class QuadraticBezier(object):
         self.point(t1) == other_seg.point(t2).
         Note: This will fail if the two segments coincide for more than a
         finite collection of points."""
+        if isinstance(other_seg, (Line, QuadraticBezier, CubicBezier)):
+            ob = [e.real for e in other_seg.bpoints()]
+            sb = [e.real for e in self.bpoints()]
+            if min(ob) > max(sb):
+                return []
+            if max(ob) < min(sb):
+                return []
+            ob = [e.imag for e in other_seg.bpoints()]
+            sb = [e.imag for e in self.bpoints()]
+            if min(ob) > max(sb):
+                return []
+            if max(ob) < min(sb):
+                return []
         if isinstance(other_seg, Line):
             return bezier_by_line_intersections(self, other_seg)
         elif isinstance(other_seg, QuadraticBezier):
@@ -1068,6 +1145,9 @@ class CubicBezier(object):
         self._length_info = {'length': None, 'bpoints': None, 'error': None,
                              'min_depth': None}
 
+    def __hash__(self):
+        return hash((self.start, self.control1, self.control2, self.end))
+
     def __repr__(self):
         return 'CubicBezier(start=%s, control1=%s, control2=%s, end=%s)' % (
             self.start, self.control1, self.control2, self.end)
@@ -1131,7 +1211,7 @@ class CubicBezier(object):
 
     def points(self, ts):
         """Faster than running Path.point many times."""
-        return self.poly(ts)
+        return self.poly()(ts)
 
     def length(self, t0=0, t1=1, error=LENGTH_ERROR, min_depth=LENGTH_MIN_DEPTH):
         """Calculate the length of the path up to a certain position"""
@@ -1239,37 +1319,51 @@ class CubicBezier(object):
 
     def intersect(self, other_seg, tol=1e-12):
         """Finds the intersections of two segments.
-        returns a list of tuples (t1, t2) such that
-        self.point(t1) == other_seg.point(t2).
-        Note: This will fail if the two segments coincide for more than a
-        finite collection of points."""
+
+        Returns:
+            (list[tuple[float]]) a list of tuples (t1, t2) such that
+            self.point(t1) == other_seg.point(t2).
+
+        Scope:
+            This will fail if the two segments coincide for more than a
+            finite collection of points.
+        """
+        if isinstance(other_seg, (Line, QuadraticBezier, CubicBezier)):
+            ob = [e.real for e in other_seg.bpoints()]
+            sb = [e.real for e in self.bpoints()]
+            if min(ob) > max(sb):
+                return []
+            if max(ob) < min(sb):
+                return []
+            ob = [e.imag for e in other_seg.bpoints()]
+            sb = [e.imag for e in self.bpoints()]
+            if min(ob) > max(sb):
+                return []
+            if max(ob) < min(sb):
+                return []
         if isinstance(other_seg, Line):
             return bezier_by_line_intersections(self, other_seg)
         elif (isinstance(other_seg, QuadraticBezier) or
               isinstance(other_seg, CubicBezier)):
             assert self != other_seg
             longer_length = max(self.length(), other_seg.length())
-            return bezier_intersections(self, other_seg,
-                                        longer_length=longer_length,
-                                        tol=tol, tol_deC=tol)
+            return bezier_intersections(
+                self, other_seg, longer_length=longer_length, tol=tol, tol_deC=tol
+            )
         elif isinstance(other_seg, Arc):
-            t2t1s = other_seg.intersect(self)
-            return [(t1, t2) for t2, t1 in t2t1s]
+            return [(t1, t2) for t2, t1 in other_seg.intersect(self)]
         elif isinstance(other_seg, Path):
-            raise TypeError(
-                "other_seg must be a path segment, not a Path object, use "
-                "Path.intersect().")
+            raise TypeError("`other_seg` must be a path segment, not a "
+                            "`Path` object, use `Path.intersect()`.")
         else:
-            raise TypeError("other_seg must be a path segment.")
+            raise TypeError("`other_seg` must be a path segment.")
 
     def bbox(self):
-        """returns the bounding box for the segment in the form
-        (xmin, xmax, ymin, ymax)."""
+        """returns bounding box in format (xmin, xmax, ymin, ymax)."""
         return bezier_bounding_box(self)
 
     def split(self, t):
-        """returns two segments, whose union is this segment and which join at
-        self.point(t)."""
+        """Splits a copy of `self` at t and returns the two subsegments."""
         bpoints1, bpoints2 = split_bezier(self.bpoints(), t)
         return CubicBezier(*bpoints1), CubicBezier(*bpoints2)
 
@@ -1281,8 +1375,8 @@ class CubicBezier(object):
     def radialrange(self, origin, return_all_global_extrema=False):
         """returns the tuples (d_min, t_min) and (d_max, t_max) which minimize
         and maximize, respectively, the distance d = |self.point(t)-origin|."""
-        return bezier_radialrange(self, origin,
-                return_all_global_extrema=return_all_global_extrema)
+        return bezier_radialrange(
+            self, origin, return_all_global_extrema=return_all_global_extrema)
 
     def rotated(self, degs, origin=None):
         """Returns a copy of self rotated by `degs` degrees (CCW) around the
@@ -1304,7 +1398,7 @@ class CubicBezier(object):
 class Arc(object):
     def __init__(self, start, radius, rotation, large_arc, sweep, end,
                  autoscale_radius=True):
-        """
+        r"""
         This should be thought of as a part of an ellipse connecting two
         points on that ellipse, start and end.
         Parameters
@@ -1642,7 +1736,7 @@ class Arc(object):
         if np.isclose(t_x_0, t_y_0):
             t = (t_x_0 + t_y_0) / 2.0
         elif np.isclose(t_x_0, t_y_1):
-            t= (t_x_0 + t_y_1) / 2.0
+            t = (t_x_0 + t_y_1) / 2.0
         elif np.isclose(t_x_1, t_y_0):
             t = (t_x_1 + t_y_0) / 2.0
         elif np.isclose(t_x_1, t_y_1):
@@ -1660,33 +1754,48 @@ class Arc(object):
         return None
 
     def centeriso(self, z):
-        """This is an isometry that translates and rotates self so that it
-        is centered on the origin and has its axes aligned with the xy axes."""
+        """Isometry to a centered aligned ellipse.
+
+        This is an isometry that shifts and rotates `self`'s underlying
+        ellipse so that it's centered on the origin and has its axes
+        aligned with the xy-axes.
+
+        Args:
+            z (:obj:`complex` or :obj:`numpy.ndarray[complex]`): a point
+                to send through the above-described isometry.
+
+        Returns:
+            (:obj:`complex` or :obj:`numpy.ndarray[complex]`) The point(s) f(z),
+                where f is the above described isometry of the xy-plane (i.e.
+                the one-dimensional complex plane).
+        """
         return (1/self.rot_matrix)*(z - self.center)
 
     def icenteriso(self, zeta):
-        """This is an isometry, the inverse of standardiso()."""
+        """The inverse of the `centeriso()` method."""
         return self.rot_matrix*zeta + self.center
 
     def u1transform(self, z):
-        """This is an affine transformation (same as used in
-        self._parameterize()) that sends self to the unit circle."""
-        zeta = (1/self.rot_matrix)*(z - self.center)  # same as centeriso(z)
+        """Similar to the `centeriso()` method, but maps to the unit circle."""
+        zeta = self.centeriso(z)
         x, y = real(zeta), imag(zeta)
         return x/self.radius.real + 1j*y/self.radius.imag
 
     def iu1transform(self, zeta):
-        """This is an affine transformation, the inverse of
-        self.u1transform()."""
+        """The inverse of the `u1transform()` method."""
         x = real(zeta)
         y = imag(zeta)
         z = x*self.radius.real + y*self.radius.imag
         return self.rot_matrix*z + self.center
 
     def length(self, t0=0, t1=1, error=LENGTH_ERROR, min_depth=LENGTH_MIN_DEPTH):
-        """The length of an elliptical large_arc segment requires numerical
+        """Computes the length of the Arc segment, `self`, from t0 to t1.
+
+        Notes:
+        * The length of an elliptical large_arc segment requires numerical
         integration, and in that case it's simpler to just do a geometric
-        approximation, as for cubic bezier curves."""
+        approximation, as for cubic bezier curves.
+        """
         assert 0 <= t0 <= 1 and 0 <= t1 <= 1
 
         if t0 == 0 and t1 == 1:
@@ -1710,8 +1819,17 @@ class Arc(object):
 
     def ilength(self, s, s_tol=ILENGTH_S_TOL, maxits=ILENGTH_MAXITS,
                 error=ILENGTH_ERROR, min_depth=ILENGTH_MIN_DEPTH):
-        """Returns a float, t, such that self.length(0, t) is approximately s.
-        See the inv_arclength() docstring for more details."""
+        """Approximates the unique `t` such that self.length(0, t) = s.
+
+        Args:
+            s (float): A length between 0 and `self.length()`.
+
+        Returns:
+             (float) The t, such that self.length(0, t) is approximately s.
+
+        For more info:
+            See the inv_arclength() docstring.
+        """
         return inv_arclength(self, s, s_tol=s_tol, maxits=maxits, error=error,
                              min_depth=min_depth)
 
@@ -1809,9 +1927,18 @@ class Arc(object):
                    not self.sweep, self.start)
 
     def phase2t(self, psi):
-        """Given phase -pi < psi <= pi,
-        returns the t value such that
-        exp(1j*psi) = self.u1transform(self.point(t)).
+        """Converts phase to t-value.
+
+        I.e. given phase, psi, such that -np.pi < psi <= np.pi, approximates
+        the unique t-value such that `self.u1transform(self.point(t))` equals
+        `np.exp(1j*psi)`.
+
+        Args:
+            psi (float): The phase in radians.
+
+        Returns:
+            (float): the corresponding t-value.
+
         """
         def _deg(rads, domain_lower_limit):
             # Convert rads to degrees in [0, 360) domain
@@ -1830,7 +1957,6 @@ class Arc(object):
             degs = _deg(psi, domain_lower_limit=self.theta)
         return (degs - self.theta)/self.delta
 
-
     def intersect(self, other_seg, tol=1e-12):
         """NOT FULLY IMPLEMENTED.  Finds the intersections of two segments.
         returns a list of tuples (t1, t2) such that
@@ -1960,11 +2086,19 @@ class Arc(object):
             return intersections
 
         elif is_bezier_segment(other_seg):
-            u1poly = self.u1transform(other_seg.poly())
+            # if self and other_seg intersect, they will itersect at the
+            # same points after being passed through the `u1transform`
+            # isometry. Since this isometry maps self to the unit circle,
+            # the intersections will be easy to find (just look for any
+            # points where other_seg is a distance of one from the origin.
+            # Moreoever, the t-values that the intersection happen at will
+            # be unchanged by the isometry.
+            u1poly = np.poly1d(self.u1transform(other_seg.poly()))
             u1poly_mag2 = real(u1poly)**2 + imag(u1poly)**2
-            t2s = polyroots01(u1poly_mag2 - 1)
+            t2s = [t for t in polyroots01(u1poly_mag2 - 1) if 0 <= t <= 1]
             t1s = [self.phase2t(phase(u1poly(t2))) for t2 in t2s]
-            return list(zip(t1s, t2s))
+
+            return [(t1, t2) for t1, t2 in zip(t1s, t2s) if 0 <= t1 <= 1]
 
         elif isinstance(other_seg, Arc):
             assert other_seg != self
@@ -2001,19 +2135,23 @@ class Arc(object):
 
                     def point_in_seg_interior(point, seg):
                         t = seg.point_to_t(point)
-                        if t is None: return False
-                        if np.isclose(t, 0.0, rtol=0.0, atol=1e-6): return False
-                        if np.isclose(t, 1.0, rtol=0.0, atol=1e-6): return False
+                        if (not t or
+                                np.isclose(t, 0.0, rtol=0.0, atol=1e-6) or
+                                np.isclose(t, 1.0, rtol=0.0, atol=1e-6)):
+                            return False
                         return True
 
                     # If either end of either segment is in the interior
                     # of the other segment, then the Arcs overlap
                     # in an infinite number of points, and we return
                     # "no intersections".
-                    if point_in_seg_interior(self.start, other_seg): return []
-                    if point_in_seg_interior(self.end, other_seg): return []
-                    if point_in_seg_interior(other_seg.start, self): return []
-                    if point_in_seg_interior(other_seg.end, self): return []
+                    if (
+                            point_in_seg_interior(self.start, other_seg) or
+                            point_in_seg_interior(self.end, other_seg) or
+                            point_in_seg_interior(other_seg.start, self) or
+                            point_in_seg_interior(other_seg.end, self)
+                    ):
+                        return []
 
                     # If they touch at their endpoint(s) and don't go
                     # in "overlapping directions", then we accept that
@@ -2316,16 +2454,6 @@ class Arc(object):
             current_t = next_t
 
 
-def is_bezier_segment(x):
-    return (isinstance(x, Line) or
-            isinstance(x, QuadraticBezier) or
-            isinstance(x, CubicBezier))
-
-
-def is_path_segment(x):
-    return is_bezier_segment(x) or isinstance(x, Arc)
-
-
 class Path(MutableSequence):
     """A Path is a sequence of path segments"""
 
@@ -2366,6 +2494,9 @@ class Path(MutableSequence):
         if 'tree_element' in kw:
             self._tree_element = kw['tree_element']
 
+    def __hash__(self):
+        return hash((tuple(self._segments), self._closed))
+
     def __getitem__(self, index):
         return self._segments[index]
 
@@ -2378,8 +2509,12 @@ class Path(MutableSequence):
     def __delitem__(self, index):
         del self._segments[index]
         self._length = None
-        self._start = self._segments[0].start
-        self._end = self._segments[-1].end
+        if len(self._segments) > 0:
+            self._start = self._segments[0].start
+            self._end = self._segments[-1].end
+        else:
+            self._start = None
+            self._end = None
 
     def __iter__(self):
         return self._segments.__iter__()
@@ -2428,33 +2563,33 @@ class Path(MutableSequence):
         lengths = [each.length(error=error, min_depth=min_depth) for each in
                    self._segments]
         self._length = sum(lengths)
-        self._lengths = [each/self._length for each in lengths]
+        if self._length == 0:
+            self._lengths = lengths  # all lengths are 0.
+        else:
+            self._lengths = [each / self._length for each in lengths]
 
-    def point(self, T):
+    def point(self, pos):
 
         # Shortcuts
-        if T == 0.0:
-            return self._segments[0].point(T)
-        if T == 1.0:
-            return self._segments[-1].point(T)
+        if len(self._segments) == 0:
+            raise ValueError("This path contains no segments!")
+        if pos == 0.0:
+            return self._segments[0].point(pos)
+        if pos == 1.0:
+            return self._segments[-1].point(pos)
 
         self._calc_lengths()
         # Find which segment the point we search for is located on:
-        cumulative_relative_lengths = np.cumsum(self._lengths)
-
-        if hasattr(T, '__iter__'):
-            T = np.array(T).reshape(1, len(T))
-            relevant_seg_indices = np.argmax(cumulative_relative_lengths[:, None] >= T, axis=0)
-            T0, T1 = cumulative_relative_lengths[relevant_seg_indices - 1],\
-                     cumulative_relative_lengths[relevant_seg_indices]
-            t = (T - T0) / (T1 - T0)
-            return [self[i].point(tval) for i, tval in zip(relevant_seg_indices, t)]
-        else:  # assume T is a scalar
-            relevant_seg_index = np.argmax(cumulative_relative_lengths >= T)
-            T0, T1 = cumulative_relative_lengths[relevant_seg_index - 1],\
-                     cumulative_relative_lengths[relevant_seg_index]
-            t = (T - T0) / (T1 - T0)
-            return self[relevant_seg_index].point(t)
+        segment_start = 0
+        for index, segment in enumerate(self._segments):
+            segment_end = segment_start + self._lengths[index]
+            if segment_end >= pos:
+                # This is the segment! How far in on the segment is the point?
+                segment_pos = (pos - segment_start)/(
+                    segment_end - segment_start)
+                return segment.point(segment_pos)
+            segment_start = segment_end
+        raise RuntimeError("Something has gone wrong.  Could not compute Path.point({}) for path {}".format(pos, self))
 
     def length(self, T0=0, T1=1, error=LENGTH_ERROR, min_depth=LENGTH_MIN_DEPTH):
         self._calc_lengths(error=error, min_depth=min_depth)
@@ -2511,7 +2646,10 @@ class Path(MutableSequence):
         return self.start == self.end
 
     def _is_closable(self):
-        end = self[-1].end
+        try:
+            end = self[-1].end
+        except IndexError:
+            return True
         for segment in self:
             if segment.start == end:
                 return True
@@ -2539,31 +2677,34 @@ class Path(MutableSequence):
 
     @property
     def start(self):
-        if not self._start:
+        if not self._start and len(self._segments)>0:
             self._start = self._segments[0].start
         return self._start
 
     @start.setter
     def start(self, pt):
         self._start = pt
-        self._segments[0].start = pt
+        if len(self._segments)>0:
+            self._segments[0].start = pt
 
     @property
     def end(self):
-        if not self._end:
+        if not self._end and len(self._segments)>0:
             self._end = self._segments[-1].end
         return self._end
 
     @end.setter
     def end(self, pt):
         self._end = pt
-        self._segments[-1].end = pt
+        if len(self._segments)>0:
+            self._segments[-1].end = pt
 
     def d(self, useSandT=False, use_closed_attrib=False, rel=False):
         """Returns a path d-string for the path object.
         For an explanation of useSandT and use_closed_attrib, see the
         compatibility notes in the README."""
-    
+        if len(self) == 0:
+            return ''
         if use_closed_attrib:
             self_closed = self.iscontinuous() and self.isclosed()
             if self_closed:
@@ -2807,10 +2948,10 @@ class Path(MutableSequence):
                 area_enclosed += integral(1) - integral(0)
             return area_enclosed
 
-        def seg2lines(seg):
+        def seg2lines(seg_):
             """Find piecewise-linear approximation of `seg`."""
-            num_lines = int(ceil(seg.length() / chord_length))
-            pts = [seg.point(t) for t in np.linspace(0, 1, num_lines+1)]
+            num_lines = int(ceil(seg_.length() / chord_length))
+            pts = [seg_.point(t) for t in np.linspace(0, 1, num_lines+1)]
             return [Line(pts[i], pts[i+1]) for i in range(num_lines)]
 
         assert self.isclosed()
@@ -2824,20 +2965,29 @@ class Path(MutableSequence):
         return area_without_arcs(Path(*bezier_path_approximation))
 
     def intersect(self, other_curve, justonemode=False, tol=1e-12):
-        """returns list of pairs of pairs ((T1, seg1, t1), (T2, seg2, t2))
-        giving the intersection points.
-        If justonemode==True, then returns just the first
-        intersection found.
-        tol is used to check for redundant intersections (see comment above
-        the code block where tol is used).
-        Note:  If the two path objects coincide for more than a finite set of
-        points, this code will fail."""
+        """Finds intersections of `self` with `other_curve`
+
+        Args:
+            other_curve: the path or path segment to check for intersections
+                with `self`
+            justonemode (bool): if true, returns only the first
+                intersection found.
+            tol (float): A tolerance used to check for redundant intersections
+                (see comment above the code block where tol is used).
+
+        Returns:
+            (list[tuple[float, Curve, float]]): list of intersections, each
+                in the format ((T1, seg1, t1), (T2, seg2, t2)), where
+                self.point(T1) == seg1.point(t1) == seg2.point(t2) == other_curve.point(T2)
+
+        Scope:
+            If the two path objects coincide for more than a finite set of
+            points, this code will iterate to max depth and/or raise an error.
+        """
         path1 = self
-        if isinstance(other_curve, Path):
-            path2 = other_curve
-        else:
-            path2 = Path(other_curve)
+        path2 = other_curve if isinstance(other_curve, Path) else Path(other_curve)
         assert path1 != path2
+
         intersection_list = []
         for seg1 in path1:
             for seg2 in path2:
@@ -2847,6 +2997,7 @@ class Path(MutableSequence):
                     T1 = path1.t2T(seg1, t1)
                     T2 = path2.t2T(seg2, t2)
                     intersection_list.append(((T1, seg1, t1), (T2, seg2, t2)))
+
         if justonemode and intersection_list:
             return intersection_list[0]
 
@@ -2855,8 +3006,7 @@ class Path(MutableSequence):
         # redundant intersection.  This code block checks for and removes said
         # redundancies.
         if intersection_list:
-            pts = [seg1.point(_t1)
-                   for _T1, _seg1, _t1 in list(zip(*intersection_list))[0]]
+            pts = [_seg1.point(_t1) for _T1, _seg1, _t1 in list(zip(*intersection_list))[0]]
             indices2remove = []
             for ind1 in range(len(pts)):
                 for ind2 in range(ind1 + 1, len(pts)):
@@ -2869,8 +3019,7 @@ class Path(MutableSequence):
         return intersection_list
 
     def bbox(self):
-        """returns a bounding box for the input Path object in the form
-        (xmin, xmax, ymin, ymax)."""
+        """returns bounding box in the form (xmin, xmax, ymin, ymax)."""
         bbs = [seg.bbox() for seg in self._segments]
         xmins, xmaxs, ymins, ymaxs = list(zip(*bbs))
         xmin = min(xmins)
@@ -3018,6 +3167,18 @@ class Path(MutableSequence):
             arc_required = int(ceil(abs(segment.delta) / sweep_limit))
             self[s:s+1] = list(segment.as_quad_curves(arc_required))
 
+    def joints(self):
+        """returns generator of segment joints 
+        
+        I.e. Path(s0, s1, s2, ..., sn).joints() returns generator 
+            (s0, s1), (s1, s2), ..., (sn, s0)
+
+        credit: https://docs.python.org/3/library/itertools.html#recipes
+        """
+        a, b = tee(self)
+        next(b, None)
+        return zip(a, b)
+
     def _tokenize_path(self, pathdef):
         for x in COMMAND_RE.split(pathdef):
             if x in COMMANDS:

svgpathtools/paths2svg.py

@@ -100,7 +100,7 @@ def disvg(paths=None, colors=None, filename=None, stroke_widths=None,
           mindim=600, dimensions=None, viewbox=None, text=None,
           text_path=None, font_size=None, attributes=None,
           svg_attributes=None, svgwrite_debug=False,
-          paths2Drawing=False):
+          paths2Drawing=False, baseunit='px'):
     """Creates (and optionally displays) an SVG file.
 
     REQUIRED INPUTS:
@@ -214,10 +214,13 @@ def disvg(paths=None, colors=None, filename=None, stroke_widths=None,
         timestamp = True if timestamp is None else timestamp
         filename = os_path.join(gettempdir(), 'disvg_output.svg')
 
+    dirname = os_path.abspath(os_path.dirname(filename))
+    if not os_path.exists(dirname):
+        makedirs(dirname)
+
     # append time stamp to filename
     if timestamp:
         fbname, fext = os_path.splitext(filename)
-        dirname = os_path.dirname(filename)
         tstamp = str(time()).replace('.', '')
         stfilename = os_path.split(fbname)[1] + '_' + tstamp + fext
         filename = os_path.join(dirname, stfilename)
@@ -313,12 +316,16 @@ def disvg(paths=None, colors=None, filename=None, stroke_widths=None,
         dy += 2*margin_size*dy + extra_space_for_style
         viewbox = "%s %s %s %s" % (xmin, ymin, dx, dy)
 
-        if dx > dy:
-            szx = str(mindim) + 'px'
-            szy = str(int(ceil(mindim * dy / dx))) + 'px'
+        if mindim is None:
+            szx = "{}{}".format(dx, baseunit)
+            szy = "{}{}".format(dy, baseunit)
         else:
-            szx = str(int(ceil(mindim * dx / dy))) + 'px'
-            szy = str(mindim) + 'px'
+            if dx > dy:
+                szx = str(mindim) + baseunit
+                szy = str(int(ceil(mindim * dy / dx))) + baseunit
+            else:
+                szx = str(int(ceil(mindim * dx / dy))) + baseunit
+                szy = str(mindim) + baseunit 
         dimensions = szx, szy
 
     # Create an SVG file
@@ -403,9 +410,6 @@ def disvg(paths=None, colors=None, filename=None, stroke_widths=None,
     if paths2Drawing:
         return dwg
       
-    # save svg
-    if not os_path.exists(os_path.dirname(filename)):
-        makedirs(os_path.dirname(filename))
     dwg.save()
 
     # re-open the svg, make the xml pretty, and save it again
@@ -428,7 +432,7 @@ def wsvg(paths=None, colors=None, filename=None, stroke_widths=None,
          mindim=600, dimensions=None, viewbox=None, text=None,
          text_path=None, font_size=None, attributes=None,
          svg_attributes=None, svgwrite_debug=False,
-         paths2Drawing=False):
+         paths2Drawing=False, baseunit='px'):
     """Create SVG and write to disk.
 
     Note: This is identical to `disvg()` except that `openinbrowser`
@@ -447,7 +451,7 @@ def wsvg(paths=None, colors=None, filename=None, stroke_widths=None,
                  text_path=text_path, font_size=font_size,
                  attributes=attributes, svg_attributes=svg_attributes,
                  svgwrite_debug=svgwrite_debug,
-                 paths2Drawing=paths2Drawing)
+                 paths2Drawing=paths2Drawing, baseunit=baseunit)
     
     
 def paths2Drawing(paths=None, colors=None, filename=None,
@@ -456,7 +460,7 @@ def paths2Drawing(paths=None, colors=None, filename=None,
                   margin_size=0.1, mindim=600, dimensions=None,
                   viewbox=None, text=None, text_path=None,
                   font_size=None, attributes=None, svg_attributes=None,
-                  svgwrite_debug=False, paths2Drawing=True):
+                  svgwrite_debug=False, paths2Drawing=True, baseunit='px'):
     """Create and return `svg.Drawing` object.
 
     Note: This is identical to `disvg()` except that `paths2Drawing`
@@ -474,4 +478,4 @@ def paths2Drawing(paths=None, colors=None, filename=None,
                  text_path=text_path, font_size=font_size,
                  attributes=attributes, svg_attributes=svg_attributes,
                  svgwrite_debug=svgwrite_debug,
-                 paths2Drawing=paths2Drawing)
+                 paths2Drawing=paths2Drawing, baseunit=baseunit)

svgpathtools/svg_io_sax.py

@@ -6,6 +6,7 @@
 from __future__ import division, absolute_import, print_function
 import os
 from xml.etree.ElementTree import iterparse, Element, ElementTree, SubElement
+import numpy as np
 
 # Internal dependencies
 from .parser import parse_path
@@ -13,13 +14,13 @@ from .parser import parse_transform
 from .svg_to_paths import (path2pathd, ellipse2pathd, line2pathd,
                            polyline2pathd, polygon2pathd, rect2pathd)
 from .misctools import open_in_browser
-from .path import *
+from .path import transform
 
 # To maintain forward/backward compatibility
 try:
-    str = basestring
+    string = basestring
 except NameError:
-    pass
+    string = str
 
 NAME_SVG = "svg"
 ATTR_VERSION = "version"
@@ -164,17 +165,17 @@ class SaxDocument:
             if matrix is not None and not np.all(np.equal(matrix, identity)):
                 matrix_string = "matrix("
                 matrix_string += " "
-                matrix_string += str(matrix[0][0])
+                matrix_string += string(matrix[0][0])
                 matrix_string += " "
-                matrix_string += str(matrix[1][0])
+                matrix_string += string(matrix[1][0])
                 matrix_string += " "
-                matrix_string += str(matrix[0][1])
+                matrix_string += string(matrix[0][1])
                 matrix_string += " "
-                matrix_string += str(matrix[1][1])
+                matrix_string += string(matrix[1][1])
                 matrix_string += " "
-                matrix_string += str(matrix[0][2])
+                matrix_string += string(matrix[0][2])
                 matrix_string += " "
-                matrix_string += str(matrix[1][2])
+                matrix_string += string(matrix[1][2])
                 matrix_string += ")"
                 path.set(ATTR_TRANSFORM, matrix_string)
             if ATTR_DATA in values:

svgpathtools/svg_to_paths.py

@@ -4,8 +4,13 @@ The main tool being the svg2paths() function."""
 # External dependencies
 from __future__ import division, absolute_import, print_function
 from xml.dom.minidom import parse
-from os import path as os_path, getcwd
+import os
+from io import StringIO
 import re
+try:
+    from os import PathLike as FilePathLike
+except ImportError:
+    FilePathLike = str
 
 # Internal dependencies
 from .parser import parse_path
@@ -17,9 +22,11 @@ COORD_PAIR_TMPLT = re.compile(
     r'([\+-]?\d*[\.\d]\d*[eE][\+-]?\d+|[\+-]?\d*[\.\d]\d*)'
 )
 
+
 def path2pathd(path):
     return path.get('d', '')
 
+
 def ellipse2pathd(ellipse):
     """converts the parameters from an ellipse or a circle to a string for a 
     Path object d-attribute"""
@@ -44,7 +51,7 @@ def ellipse2pathd(ellipse):
     d += 'a' + str(rx) + ',' + str(ry) + ' 0 1,0 ' + str(2 * rx) + ',0'
     d += 'a' + str(rx) + ',' + str(ry) + ' 0 1,0 ' + str(-2 * rx) + ',0'
 
-    return d
+    return d + 'z'
 
 
 def polyline2pathd(polyline, is_polygon=False):
@@ -84,14 +91,39 @@ def rect2pathd(rect):
     
     The rectangle will start at the (x,y) coordinate specified by the 
     rectangle object and proceed counter-clockwise."""
-    x0, y0 = float(rect.get('x', 0)), float(rect.get('y', 0))
+    x, y = float(rect.get('x', 0)), float(rect.get('y', 0))
     w, h = float(rect.get('width', 0)), float(rect.get('height', 0))
-    x1, y1 = x0 + w, y0
-    x2, y2 = x0 + w, y0 + h
-    x3, y3 = x0, y0 + h
+    if 'rx' in rect or 'ry' in rect:
+
+        # if only one, rx or ry, is present, use that value for both
+        # https://developer.mozilla.org/en-US/docs/Web/SVG/Element/rect
+        rx = rect.get('rx', None)
+        ry = rect.get('ry', None)
+        if rx is None:
+            rx = ry or 0.
+        if ry is None:
+            ry = rx or 0.
+        rx, ry = float(rx), float(ry)
+
+        d = "M {} {} ".format(x + rx, y)  # right of p0
+        d += "L {} {} ".format(x + w - rx, y)  # go to p1
+        d += "A {} {} 0 0 1 {} {} ".format(rx, ry, x+w, y+ry)  # arc for p1
+        d += "L {} {} ".format(x+w, y+h-ry)  # above p2
+        d += "A {} {} 0 0 1 {} {} ".format(rx, ry, x+w-rx, y+h)  # arc for p2
+        d += "L {} {} ".format(x+rx, y+h)  # right of p3
+        d += "A {} {} 0 0 1 {} {} ".format(rx, ry, x, y+h-ry)  # arc for p3
+        d += "L {} {} ".format(x, y+ry)  # below p0
+        d += "A {} {} 0 0 1 {} {} z".format(rx, ry, x+rx, y)  # arc for p0
+        return d
+
+    x0, y0 = x, y
+    x1, y1 = x + w, y
+    x2, y2 = x + w, y + h
+    x3, y3 = x, y + h
 
     d = ("M{} {} L {} {} L {} {} L {} {} z"
          "".format(x0, y0, x1, y1, x2, y2, x3, y3))
+        
     return d
 
 
@@ -117,7 +149,9 @@ def svg2paths(svg_file_location,
     SVG Path, Line, Polyline, Polygon, Circle, and Ellipse elements.
 
     Args:
-        svg_file_location (string): the location of the svg file
+        svg_file_location (string or file-like object): the location of the
+            svg file on disk or a file-like object containing the content of a
+            svg file
         return_svg_attributes (bool): Set to True and a dictionary of
             svg-attributes will be extracted and returned.  See also the 
             `svg2paths2()` function.
@@ -141,8 +175,10 @@ def svg2paths(svg_file_location,
         list: The list of corresponding path attribute dictionaries.
         dict (optional): A dictionary of svg-attributes (see `svg2paths2()`).
     """
-    if os_path.dirname(svg_file_location) == '':
-        svg_file_location = os_path.join(getcwd(), svg_file_location)
+    # strings are interpreted as file location everything else is treated as
+    # file-like object and passed to the xml parser directly
+    from_filepath = isinstance(svg_file_location, str) or isinstance(svg_file_location, FilePathLike)
+    svg_file_location = os.path.abspath(svg_file_location) if from_filepath else svg_file_location
 
     doc = parse(svg_file_location)
 
@@ -222,3 +258,26 @@ def svg2paths2(svg_file_location,
                      convert_polylines_to_paths=convert_polylines_to_paths,
                      convert_polygons_to_paths=convert_polygons_to_paths,
                      convert_rectangles_to_paths=convert_rectangles_to_paths)
+
+
+def svgstr2paths(svg_string,
+               return_svg_attributes=False,
+               convert_circles_to_paths=True,
+               convert_ellipses_to_paths=True,
+               convert_lines_to_paths=True,
+               convert_polylines_to_paths=True,
+               convert_polygons_to_paths=True,
+               convert_rectangles_to_paths=True):
+    """Convenience function; identical to svg2paths() except that it takes the
+    svg object as string.  See svg2paths() docstring for more
+    info."""
+    # wrap string into StringIO object
+    svg_file_obj = StringIO(svg_string)
+    return svg2paths(svg_file_location=svg_file_obj,
+                     return_svg_attributes=return_svg_attributes,
+                     convert_circles_to_paths=convert_circles_to_paths,
+                     convert_ellipses_to_paths=convert_ellipses_to_paths,
+                     convert_lines_to_paths=convert_lines_to_paths,
+                     convert_polylines_to_paths=convert_polylines_to_paths,
+                     convert_polygons_to_paths=convert_polygons_to_paths,
+                     convert_rectangles_to_paths=convert_rectangles_to_paths)

test/negative-scale.svg

@@ -0,0 +1,19 @@
+<?xml version="1.0"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg width="100mm" height="100mm" viewBox="-100 -200 500 500" xmlns="http://www.w3.org/2000/svg" version="1.1">
+    <g id="Sketch" transform="scale(1,-1)">
+        <path id="slot" d="
+            M 0 10
+            L 0 80
+            A 30 30 0 1 0 0 140
+            A 10 10 0 0 1 0 100
+            L 100 100
+            A 10 10 0 1 1 100 140
+            A 30 30 0 0 0 100 80
+            L 100 10
+            A 10 10 0 0 0 90 0
+            L 10 0
+            A 10 10 0 0 0 0 10
+        " stroke="#ff0000" stroke-width="0.35 px"/>
+    </g>
+</svg>

test/test_bezier.py

@@ -1,7 +1,7 @@
 from __future__ import division, absolute_import, print_function
 import numpy as np
 import unittest
-from svgpathtools.bezier import *
+from svgpathtools.bezier import bezier_point, bezier2polynomial, polynomial2bezier
 from svgpathtools.path import bpoints2bezier
 
 

test/test_document.py

@@ -0,0 +1,54 @@
+from __future__ import division, absolute_import, print_function
+import unittest
+from svgpathtools import Document
+from io import StringIO
+from io import open  # overrides build-in open for compatibility with python2
+from os.path import join, dirname
+from sys import version_info
+
+
+class TestDocument(unittest.TestCase):
+    def test_from_file_path_string(self):
+        """Test reading svg from file provided as path"""
+        doc = Document(join(dirname(__file__), 'polygons.svg'))
+
+        self.assertEqual(len(doc.paths()), 2)
+
+    def test_from_file_path(self):
+        """Test reading svg from file provided as path"""
+        if version_info >= (3, 6):
+            import pathlib
+            doc = Document(pathlib.Path(__file__).parent / 'polygons.svg')
+
+            self.assertEqual(len(doc.paths()), 2)
+
+    def test_from_file_object(self):
+        """Test reading svg from file object that has already been opened"""
+        with open(join(dirname(__file__), 'polygons.svg'), 'r') as file:
+            doc = Document(file)
+
+            self.assertEqual(len(doc.paths()), 2)
+
+    def test_from_stringio(self):
+        """Test reading svg object contained in a StringIO object"""
+        with open(join(dirname(__file__), 'polygons.svg'),
+                  'r', encoding='utf-8') as file:
+            # read entire file into string
+            file_content = file.read()
+            # prepare stringio object
+            file_as_stringio = StringIO(file_content)
+
+            doc = Document(file_as_stringio)
+
+            self.assertEqual(len(doc.paths()), 2)
+
+    def test_from_string(self):
+        """Test reading svg object contained in a string"""
+        with open(join(dirname(__file__), 'polygons.svg'),
+                  'r', encoding='utf-8') as file:
+            # read entire file into string
+            file_content = file.read()
+
+            doc = Document.from_svg_string(file_content)
+
+            self.assertEqual(len(doc.paths()), 2)

test/test_generation.py

@@ -2,7 +2,7 @@
 #------------------------------------------------------------------------------
 from __future__ import division, absolute_import, print_function
 import unittest
-from svgpathtools import *
+from svgpathtools import parse_path
 
 
 class TestGeneration(unittest.TestCase):

test/test_groups.py

@@ -5,11 +5,15 @@ $ python -m unittest test.test_groups.TestGroups.test_group_flatten
 """
 from __future__ import division, absolute_import, print_function
 import unittest
-from svgpathtools import *
+from svgpathtools import Document, SVG_NAMESPACE, parse_path, Line, Arc
 from os.path import join, dirname
 import numpy as np
 
 
+# When an assert fails, show the full error message, don't truncate it.
+unittest.util._MAX_LENGTH = 999999999
+
+
 def get_desired_path(name, paths):
     return next(p for p in paths
                 if p.element.get('{some://testuri}name') == name)
@@ -42,6 +46,22 @@ class TestGroups(unittest.TestCase):
         self.check_values(tf.dot(v_s), actual.start)
         self.check_values(tf.dot(v_e), actual.end)
 
+    def test_group_transform(self):
+        # The input svg has a group transform of "scale(1,-1)", which
+        # can mess with Arc sweeps.
+        doc = Document(join(dirname(__file__), 'negative-scale.svg'))
+        path = doc.paths()[0]
+        self.assertEqual(path[0], Line(start=-10j, end=-80j))
+        self.assertEqual(path[1], Arc(start=-80j, radius=(30+30j), rotation=0.0, large_arc=True, sweep=True, end=-140j))
+        self.assertEqual(path[2], Arc(start=-140j, radius=(20+20j), rotation=0.0, large_arc=False, sweep=False, end=-100j))
+        self.assertEqual(path[3], Line(start=-100j, end=(100-100j)))
+        self.assertEqual(path[4], Arc(start=(100-100j), radius=(20+20j), rotation=0.0, large_arc=True, sweep=False, end=(100-140j)))
+        self.assertEqual(path[5], Arc(start=(100-140j), radius=(30+30j), rotation=0.0, large_arc=False, sweep=True, end=(100-80j)))
+        self.assertEqual(path[6], Line(start=(100-80j), end=(100-10j)))
+        self.assertEqual(path[7], Arc(start=(100-10j), radius=(10+10j), rotation=0.0, large_arc=False, sweep=True, end=(90+0j)))
+        self.assertEqual(path[8], Line(start=(90+0j), end=(10+0j)))
+        self.assertEqual(path[9], Arc(start=(10+0j), radius=(10+10j), rotation=0.0, large_arc=False, sweep=True, end=-10j))
+
     def test_group_flatten(self):
         # Test the Document.paths() function against the
         # groups.svg test file.
@@ -235,4 +255,11 @@ class TestGroups(unittest.TestCase):
 
         path = parse_path(path_d)
         svg_path = doc.add_path(path, group=new_leaf)
-        self.assertEqual(path_d, svg_path.get('d'))
+        self.assertEqual(path_d, svg_path.get('d'))
+
+        # Test that paths are added to the correct group
+        new_sibling = doc.get_or_add_group(
+            ['base_group', 'new_parent', 'new_sibling'])
+        doc.add_path(path, group=new_sibling)
+        self.assertEqual(len(new_sibling), 1)
+        self.assertEqual(path_d, new_sibling[0].get('d'))

test/test_parsing.py

@@ -1,8 +1,9 @@
 # Note: This file was taken mostly as is from the svg.path module (v 2.0)
 from __future__ import division, absolute_import, print_function
 import unittest
-from svgpathtools import *
+from svgpathtools import Path, Line, QuadraticBezier, CubicBezier, Arc, parse_path
 import svgpathtools
+
 import numpy as np
 
 

test/test_polytools.py

@@ -4,7 +4,7 @@ import unittest
 import numpy as np
 
 # Internal dependencies
-from svgpathtools import *
+from svgpathtools import rational_limit
 
 
 class Test_polytools(unittest.TestCase):

test/test_sax_groups.py

@@ -1,6 +1,6 @@
 from __future__ import division, absolute_import, print_function
 import unittest
-from svgpathtools import *
+from svgpathtools import SaxDocument
 from os.path import join, dirname
 
 

test/test_svg2paths.py

@@ -1,7 +1,16 @@
 from __future__ import division, absolute_import, print_function
 import unittest
-from svgpathtools import *
+from svgpathtools import Path, Line, Arc, svg2paths, svgstr2paths
+from io import StringIO
+from io import open  # overrides build-in open for compatibility with python2
+import os
 from os.path import join, dirname
+from sys import version_info
+import tempfile
+import shutil
+
+from svgpathtools.svg_to_paths import rect2pathd
+
 
 class TestSVG2Paths(unittest.TestCase):
     def test_svg2paths_polygons(self):
@@ -50,3 +59,78 @@ class TestSVG2Paths(unittest.TestCase):
         self.assertTrue(len(path_circle)==2)
         self.assertTrue(path_circle==path_circle_correct)
         self.assertTrue(path_circle.isclosed())
+
+        # test for issue #198 (circles not being closed)
+        svg = u"""<?xml version="1.0" encoding="UTF-8"?>
+        <svg xmlns="http://www.w3.org/2000/svg" xmlns:svg="http://www.w3.org/2000/svg" width="40mm" height="40mm" 
+          viewBox="0 0 40 40" version="1.1">
+            
+          <g id="layer">
+            <circle id="c1" cx="20.000" cy="20.000" r="11.000" />
+            <circle id="c2" cx="20.000" cy="20.000" r="5.15" />
+          </g>
+        </svg>"""
+        tmpdir = tempfile.mkdtemp()
+        svgfile = os.path.join(tmpdir, 'test.svg')
+        with open(svgfile, 'w') as f:
+            f.write(svg)
+        paths, _ = svg2paths(svgfile)
+        self.assertEqual(len(paths), 2)
+        self.assertTrue(paths[0].isclosed())
+        self.assertTrue(paths[1].isclosed())
+        shutil.rmtree(tmpdir)
+
+    def test_rect2pathd(self):
+        non_rounded = {"x":"10", "y":"10", "width":"100","height":"100"}
+        self.assertEqual(rect2pathd(non_rounded), 'M10.0 10.0 L 110.0 10.0 L 110.0 110.0 L 10.0 110.0 z')
+        rounded = {"x":"10", "y":"10", "width":"100","height":"100", "rx":"15", "ry": "12"}
+        self.assertEqual(rect2pathd(rounded), "M 25.0 10.0 L 95.0 10.0 A 15.0 12.0 0 0 1 110.0 22.0 L 110.0 98.0 A 15.0 12.0 0 0 1 95.0 110.0 L 25.0 110.0 A 15.0 12.0 0 0 1 10.0 98.0 L 10.0 22.0 A 15.0 12.0 0 0 1 25.0 10.0 z")
+
+    def test_from_file_path_string(self):
+        """Test reading svg from file provided as path"""
+        paths, _ = svg2paths(join(dirname(__file__), 'polygons.svg'))
+
+        self.assertEqual(len(paths), 2)
+
+    def test_from_file_path(self):
+        """Test reading svg from file provided as pathlib POSIXPath"""
+        if version_info >= (3, 6):
+            import pathlib
+            paths, _ = svg2paths(pathlib.Path(__file__).parent / 'polygons.svg')
+
+            self.assertEqual(len(paths), 2)
+
+    def test_from_file_object(self):
+        """Test reading svg from file object that has already been opened"""
+        with open(join(dirname(__file__), 'polygons.svg'), 'r') as file:
+            paths, _ = svg2paths(file)
+
+            self.assertEqual(len(paths), 2)
+
+    def test_from_stringio(self):
+        """Test reading svg object contained in a StringIO object"""
+        with open(join(dirname(__file__), 'polygons.svg'),
+                  'r', encoding='utf-8') as file:
+            # read entire file into string
+            file_content = file.read()
+            # prepare stringio object
+            file_as_stringio = StringIO(file_content)
+
+            paths, _ = svg2paths(file_as_stringio)
+
+            self.assertEqual(len(paths), 2)
+
+    def test_from_string(self):
+        """Test reading svg object contained in a string"""
+        with open(join(dirname(__file__), 'polygons.svg'),
+                  'r', encoding='utf-8') as file:
+            # read entire file into string
+            file_content = file.read()
+
+            paths, _ = svgstr2paths(file_content)
+
+            self.assertEqual(len(paths), 2)
+
+
+if __name__ == '__main__':
+    unittest.main()