shapely 1.5.5__tar.gz → 1.5.7__tar.gz

{Shapely-1.5.5 → Shapely-1.5.7}/CHANGES.txt

@@ -1,6 +1,15 @@
 Changes
 =======
 
+1.5.6 (2015-03-16)
+------------------
+- Test and fix buggy error and notice handlers (#249).
+
+1.5.6 (2015-02-02)
+------------------
+- Fix setup regression (#232, #234).
+- SVG representation improvements (#233, #237).
+
 1.5.5 (2015-01-20)
 ------------------
 - MANIFEST changes to restore _geox.pxi (#231).

{Shapely-1.5.5/Shapely.egg-info → Shapely-1.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: Shapely
-Version: 1.5.5
+Version: 1.5.7
 Summary: Geometric objects, predicates, and operations
 Home-page: https://github.com/Toblerity/Shapely
 Author: Sean Gillies
@@ -215,6 +215,15 @@ Description: =======
         Changes
         =======
         
+        1.5.6 (2015-03-16)
+        ------------------
+        - Test and fix buggy error and notice handlers (#249).
+        
+        1.5.6 (2015-02-02)
+        ------------------
+        - Fix setup regression (#232, #234).
+        - SVG representation improvements (#233, #237).
+        
         1.5.5 (2015-01-20)
         ------------------
         - MANIFEST changes to restore _geox.pxi (#231).

{Shapely-1.5.5 → Shapely-1.5.7/Shapely.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: Shapely
-Version: 1.5.5
+Version: 1.5.7
 Summary: Geometric objects, predicates, and operations
 Home-page: https://github.com/Toblerity/Shapely
 Author: Sean Gillies
@@ -215,6 +215,15 @@ Description: =======
         Changes
         =======
         
+        1.5.6 (2015-03-16)
+        ------------------
+        - Test and fix buggy error and notice handlers (#249).
+        
+        1.5.6 (2015-02-02)
+        ------------------
+        - Fix setup regression (#232, #234).
+        - SVG representation improvements (#233, #237).
+        
         1.5.5 (2015-01-20)
         ------------------
         - MANIFEST changes to restore _geox.pxi (#231).

{Shapely-1.5.5 → Shapely-1.5.7}/Shapely.egg-info/SOURCES.txt

@@ -68,6 +68,7 @@ tests/test_emptiness.py
 tests/test_equality.py
 tests/test_geointerface.py
 tests/test_geomseq.py
+tests/test_geos_err_handler.py
 tests/test_getitem.py
 tests/test_hash.py
 tests/test_invalid_geometries.py
@@ -96,6 +97,7 @@ tests/test_singularity.py
 tests/test_snap.py
 tests/test_strtree.py
 tests/test_styles.py
+tests/test_svg.py
 tests/test_transform.py
 tests/test_union.py
 tests/test_validation.py

Shapely-1.5.7/VERSION.txt

@@ -0,0 +1 @@
+1.5.7

{Shapely-1.5.5 → Shapely-1.5.7}/setup.py

@@ -2,19 +2,15 @@
 
 from __future__ import print_function
 
-import ctypes
-import ctypes.util
 try:
     # If possible, use setuptools
     from setuptools import setup
     from setuptools.extension import Extension
     from setuptools.command.build_ext import build_ext as distutils_build_ext
-    from setuptools.command.install import install
 except ImportError:
     from distutils.core import setup
     from distutils.extension import Extension
     from distutils.command.build_ext import build_ext as distutils_build_ext
-    from distutils.command.install import install
 from distutils.cmd import Command
 from distutils.errors import CCompilerError, DistutilsExecError, \
     DistutilsPlatformError
@@ -23,7 +19,6 @@ import errno
 import glob
 import os
 import platform
-import re
 import shutil
 import subprocess
 import sys
@@ -58,74 +53,6 @@ with open('CHANGES.txt', 'r', **open_kwds) as fp:
 
 long_description = readme + '\n\n' + credits + '\n\n' + changes
 
-# Fail installation if we can't find a GEOS shared library with the right
-# version. We ship it with Shapely for Windows, so no need to check on that
-# platform. Code below copied from shapely/geos.py.
-class InstallCommand(install):
-
-    def run(self):
-        def load_dll(libname, fallbacks=None):
-            lib = ctypes.util.find_library(libname)
-            if lib is not None:
-                try:
-                    return ctypes.CDLL(lib)
-                except OSError:
-                    pass
-            if fallbacks is not None:
-                for name in fallbacks:
-                    try:
-                        return ctypes.CDLL(name)
-                    except OSError:
-                        # move on to the next fallback
-                        pass
-            # No shared library was loaded. Raise OSError.
-            raise OSError(
-                "Could not find library %s or load any of its variants %s" % (
-                    libname, fallbacks or []))
-
-        if sys.platform.startswith('linux'):
-            _lgeos = load_dll(
-                'geos_c', fallbacks=['libgeos_c.so.1', 'libgeos_c.so'])
-        elif sys.platform == 'darwin':
-            if hasattr(sys, 'frozen'):
-                # .app file from py2app
-                alt_paths = [os.path.join(os.environ['RESOURCEPATH'],
-                             '..', 'Frameworks', 'libgeos_c.dylib')]
-            else:
-                alt_paths = [
-                    # The Framework build from Kyng Chaos:
-                    "/Library/Frameworks/GEOS.framework/Versions/Current/GEOS",
-                    # macports
-                    '/opt/local/lib/libgeos_c.dylib',
-                ]
-            _lgeos = load_dll('geos_c', fallbacks=alt_paths)
-        elif sys.platform == 'sunos5':
-            _lgeos = load_dll(
-                'geos_c', fallbacks=['libgeos_c.so.1', 'libgeos_c.so'])
-        else:  # other *nix systems
-            _lgeos = load_dll(
-                'geos_c', fallbacks=['libgeos_c.so.1', 'libgeos_c.so'])
-
-        GEOSversion = _lgeos.GEOSversion
-        GEOSversion.restype = ctypes.c_char_p
-        GEOSversion.argtypes = []
-        geos_version_string = GEOSversion()
-        if sys.version_info[0] >= 3:
-            geos_version_string = geos_version_string.decode('ascii')
-        res = re.findall(r'(\d+)\.(\d+)\.(\d+)', geos_version_string)
-        assert len(res) == 2, res
-        geos_version = tuple(int(x) for x in res[0])
-        shapely_version = tuple(int(x) for x in version.split('.'))
-
-        if shapely_version >= (1, 3):
-            if geos_version >= (3, 3):
-                install.run(self)
-            else:
-                print(
-                    "Shapely >= 1.3 requires GEOS >= 3.3. "
-                    "Install GEOS 3.3+ and reinstall Shapely.")
-                sys.exit(1)
-
 setup_args = dict(
     name                = 'Shapely',
     version             = version,
@@ -147,7 +74,7 @@ setup_args = dict(
         'shapely.speedups',
         'shapely.vectorized',
     ],
-    cmdclass = {'install': InstallCommand},
+    cmdclass = {},
     classifiers         = [
         'Development Status :: 5 - Production/Stable',
         'Intended Audience :: Developers',
@@ -162,7 +89,7 @@ setup_args = dict(
     data_files         = [('shapely', ['shapely/_geos.pxi'])]
 )
 
-# Add DLLs to Windows packages.
+# Add DLLs for Windows
 if sys.platform == 'win32':
     try:
         os.mkdir('shapely/DLLs')

Shapely-1.5.7/shapely/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.5.7"

{Shapely-1.5.5 → Shapely-1.5.7}/shapely/ctypes_declarations.py

@@ -14,7 +14,7 @@ class allocated_c_char_p(c_char_p):
     '''char pointer return type'''
     pass
 
-EXCEPTION_HANDLER_FUNCTYPE = CFUNCTYPE(None, c_char_p, c_char_p)
+EXCEPTION_HANDLER_FUNCTYPE = CFUNCTYPE(None, c_char_p, c_void_p)
 
 
 def prototype(lgeos, geos_version):

{Shapely-1.5.5 → Shapely-1.5.7}/shapely/geometry/base.py

@@ -353,35 +353,47 @@ class BaseGeometry(object):
         """WKB hex representation of the geometry"""
         return WKBWriter(lgeos).write_hex(self)
 
-    def svg(self, scale_factor=1.):
-        """
-        SVG representation of the geometry. Scale factor is multiplied by
-        the size of the SVG symbol so it can be scaled consistently for a
-        consistent appearance based on the canvas size.
-        """
+    def svg(self, scale_factor=1., **kwargs):
+        """Raises NotImplementedError"""
         raise NotImplementedError
 
     def _repr_svg_(self):
         """SVG representation for iPython notebook"""
-        #Pick an arbitrary size for the SVG canvas
-
-
-        xmin, ymin, xmax, ymax = self.buffer(1).bounds
-        x_size = min([max([100., xmax - xmin]), 300])
-        y_size = min([max([100., ymax - ymin]), 300])
-        try:
-            scale_factor = max([xmax - xmin, ymax - ymin]) / max([x_size, y_size])
-        except ZeroDivisionError:
-            scale_factor = 1
-        buffered_box = "{0} {1} {2} {3}".format(xmin, ymin, xmax - xmin, ymax - ymin)
-        return """<svg
-            preserveAspectRatio="xMinYMin meet"
-            viewBox="{0}"
-            width="{1}"
-            height="{2}"
-            transform="translate(0, {1}),scale(1, -1)">
-            {3}
-            </svg>""".format(buffered_box, x_size, y_size, self.svg(scale_factor))
+        svg_top = '<svg xmlns="http://www.w3.org/2000/svg" ' \
+            'xmlns:xlink="http://www.w3.org/1999/xlink" '
+        if self.is_empty:
+            return svg_top + '/>'
+        else:
+            # Establish SVG canvas that will fit all the data + small space
+            xmin, ymin, xmax, ymax = self.bounds
+            if xmin == xmax and ymin == ymax:
+                # This is a point; buffer using an arbitrary size
+                xmin, ymin, xmax, ymax = self.buffer(1).bounds
+            else:
+                # Expand bounds by a fraction of the data ranges
+                expand = 0.04  # or 4%, same as R plots
+                widest_part = max([xmax - xmin, ymax - ymin])
+                expand_amount = widest_part * expand
+                xmin -= expand_amount
+                ymin -= expand_amount
+                xmax += expand_amount
+                ymax += expand_amount
+            dx = xmax - xmin
+            dy = ymax - ymin
+            width = min([max([100., dx]), 300])
+            height = min([max([100., dy]), 300])
+            try:
+                scale_factor = max([dx, dy]) / max([width, height])
+            except ZeroDivisionError:
+                scale_factor = 1.
+            view_box = "{0} {1} {2} {3}".format(xmin, ymin, dx, dy)
+            transform = "matrix(1,0,0,-1,0,{0})".format(ymax + ymin)
+            return svg_top + (
+                'width="{1}" height="{2}" viewBox="{0}" '
+                'preserveAspectRatio="xMinYMin meet">'
+                '<g transform="{3}">{4}</g></svg>'
+                ).format(view_box, width, height, transform,
+                         self.svg(scale_factor))
 
     @property
     def geom_type(self):
@@ -744,13 +756,24 @@ class BaseMultipartGeometry(BaseGeometry):
 
     __hash__ = object.__hash__
 
-    def svg(self, scale_factor=1.):
-        """
-        SVG representation of the geometry. Scale factor is multiplied by
-        the size of the SVG symbol so it can be scaled consistently for a
-        consistent appearance based on the canvas size.
+    def svg(self, scale_factor=1., color=None):
+        """Returns a group of SVG elements for the multipart geometry.
+
+        Parameters
+        ==========
+        scale_factor : float
+            Multiplication factor for the SVG stroke-width.  Default is 1.
+        color : str, optional
+            Hex string for stroke or fill color. Default is to use "#66cc99"
+            if geometry is valid, and "#ff3333" if invalid.
         """
-        return "\n".join([g.svg(scale_factor) for g in self])
+        if self.is_empty:
+            return '<g />'
+        if color is None:
+            color = "#66cc99" if self.is_valid else "#ff3333"
+        return '<g>' + \
+            ''.join(p.svg(scale_factor, color) for p in self) + \
+            '</g>'
 
 
 class GeometrySequence(object):

{Shapely-1.5.5 → Shapely-1.5.7}/shapely/geometry/linestring.py

@@ -55,23 +55,26 @@ class LineString(BaseGeometry):
             'coordinates': tuple(self.coords)
             }
 
-    def svg(self, scale_factor=1.):
-        """
-        SVG representation of the geometry. Scale factor is multiplied by
-        the size of the SVG symbol so it can be scaled consistently for a
-        consistent appearance based on the canvas size.
+    def svg(self, scale_factor=1., stroke_color=None):
+        """Returns SVG polyline element for the LineString geometry.
+
+        Parameters
+        ==========
+        scale_factor : float
+            Multiplication factor for the SVG stroke-width.  Default is 1.
+        stroke_color : str, optional
+            Hex string for stroke color. Default is to use "#66cc99" if
+            geometry is valid, and "#ff3333" if invalid.
         """
+        if self.is_empty:
+            return '<g />'
+        if stroke_color is None:
+            stroke_color = "#66cc99" if self.is_valid else "#ff3333"
         pnt_format = " ".join(["{0},{1}".format(*c) for c in self.coords])
-        return """<polyline
-            fill="none"
-            stroke="{2}"
-            stroke-width={1}
-            points="{0}"
-            opacity=".8"
-            />""".format(
-                pnt_format,
-                2.*scale_factor, 
-                "#66cc99" if self.is_valid else "#ff3333")
+        return (
+            '<polyline fill="none" stroke="{2}" stroke-width="{1}" '
+            'points="{0}" opacity="0.8" />'
+            ).format(pnt_format, 2. * scale_factor, stroke_color)
 
     @property
     def ctypes(self):

{Shapely-1.5.5 → Shapely-1.5.7}/shapely/geometry/multilinestring.py

@@ -61,26 +61,24 @@ class MultiLineString(BaseMultipartGeometry):
             'coordinates': tuple(tuple(c for c in g.coords) for g in self.geoms)
             }
 
-    def svg(self, scale_factor=1.):
-        """
-        SVG representation of the geometry. Scale factor is multiplied by
-        the size of the SVG symbol so it can be scaled consistently for a
-        consistent appearance based on the canvas size.
+    def svg(self, scale_factor=1., stroke_color=None):
+        """Returns a group of SVG polyline elements for the LineString geometry.
+
+        Parameters
+        ==========
+        scale_factor : float
+            Multiplication factor for the SVG stroke-width.  Default is 1.
+        stroke_color : str, optional
+            Hex string for stroke color. Default is to use "#66cc99" if
+            geometry is valid, and "#ff3333" if invalid.
         """
-        parts = []
-        for part in self.geoms:
-            pnt_format = " ".join(["{0},{1}".format(*c) for c in part.coords])
-            parts.append("""<polyline
-                fill="none"
-                stroke="{2}"
-                stroke-width={1}
-                points="{0}"
-                opacity=".8"
-                />""".format(
-                    pnt_format,
-                    2.*scale_factor,
-                    "#66cc99" if self.is_valid else "#ff3333"))
-        return "\n".join(parts)
+        if self.is_empty:
+            return '<g />'
+        if stroke_color is None:
+            stroke_color = "#66cc99" if self.is_valid else "#ff3333"
+        return '<g>' + \
+            ''.join(p.svg(scale_factor, stroke_color) for p in self) + \
+            '</g>'
 
 
 class MultiLineStringAdapter(CachingGeometryProxy, MultiLineString):

{Shapely-1.5.5 → Shapely-1.5.7}/shapely/geometry/multipoint.py

@@ -69,28 +69,24 @@ class MultiPoint(BaseMultipartGeometry):
             'coordinates': tuple([g.coords[0] for g in self.geoms])
             }
 
-    def svg(self, scale_factor=1.):
-        """
-        SVG representation of the geometry. Scale factor is multiplied by
-        the size of the SVG symbol so it can be scaled consistently for a
-        consistent appearance based on the canvas size.
+    def svg(self, scale_factor=1., fill_color=None):
+        """Returns a group of SVG circle elements for the MultiPoint geometry.
+
+        Parameters
+        ==========
+        scale_factor : float
+            Multiplication factor for the SVG circle diameters.  Default is 1.
+        fill_color : str, optional
+            Hex string for fill color. Default is to use "#66cc99" if
+            geometry is valid, and "#ff3333" if invalid.
         """
-        
-        parts = []
-        for part in self.geoms:
-            parts.append("""<circle
-            cx="{0.x}"
-            cy="{0.y}"
-            r="{1}"
-            stroke="#555555"
-            stroke-width="{2}"
-            fill="{3}"
-            opacity=".6"
-            />""".format(
-                part,
-                3*scale_factor,
-                1*scale_factor, "#66cc99" if self.is_valid else "#ff3333"))
-        return "\n".join(parts)
+        if self.is_empty:
+            return '<g />'
+        if fill_color is None:
+            fill_color = "#66cc99" if self.is_valid else "#ff3333"
+        return '<g>' + \
+            ''.join(p.svg(scale_factor, fill_color) for p in self) + \
+            '</g>'
 
     @property
     @exceptNull

{Shapely-1.5.5 → Shapely-1.5.7}/shapely/geometry/multipolygon.py

@@ -80,29 +80,24 @@ class MultiPolygon(BaseMultipartGeometry):
             'coordinates': allcoords
             }
 
-    def svg(self, scale_factor=1.):
-        """
-        SVG representation of the geometry. Scale factor is multiplied by
-        the size of the SVG symbol so it can be scaled consistently for a
-        consistent appearance based on the canvas size.
+    def svg(self, scale_factor=1., fill_color=None):
+        """Returns group of SVG path elements for the MultiPolygon geometry.
+
+        Parameters
+        ==========
+        scale_factor : float
+            Multiplication factor for the SVG stroke-width.  Default is 1.
+        fill_color : str, optional
+            Hex string for fill color. Default is to use "#66cc99" if
+            geometry is valid, and "#ff3333" if invalid.
         """
-        parts = []
-        for part in self.geoms:
-            exterior_coords = [["{0},{1}".format(*c) for c in part.exterior.coords]]
-            interior_coords = [
-                ["{0},{1}".format(*c) for c in interior.coords]
-                for interior in part.interiors ]
-            path = " ".join([
-                "M {0} L {1} z".format(coords[0], " L ".join(coords[1:]))
-                for coords in exterior_coords + interior_coords ])
-            parts.append(
-                """<g fill-rule="evenodd" fill="{2}" stroke="#555555"
-                stroke-width="{0}" opacity="0.6">
-                <path d="{1}" /></g>""".format(
-                    2. * scale_factor,
-                    path,
-                    "#66cc99" if self.is_valid else "#ff3333"))
-        return "\n".join(parts)
+        if self.is_empty:
+            return '<g />'
+        if fill_color is None:
+            fill_color = "#66cc99" if self.is_valid else "#ff3333"
+        return '<g>' + \
+            ''.join(p.svg(scale_factor, fill_color) for p in self) + \
+            '</g>'
 
 
 class MultiPolygonAdapter(CachingGeometryProxy, MultiPolygon):

{Shapely-1.5.5 → Shapely-1.5.7}/shapely/geometry/point.py

@@ -74,25 +74,25 @@ class Point(BaseGeometry):
             'coordinates': self.coords[0]
             }
 
-    def svg(self, scale_factor=1.):
-        """
-        SVG representation of the geometry. Scale factor is multiplied by
-        the size of the SVG symbol so it can be scaled consistently for a
-        consistent appearance based on the canvas size.
+    def svg(self, scale_factor=1., fill_color=None):
+        """Returns SVG circle element for the Point geometry.
+
+        Parameters
+        ==========
+        scale_factor : float
+            Multiplication factor for the SVG circle diameter.  Default is 1.
+        fill_color : str, optional
+            Hex string for fill color. Default is to use "#66cc99" if
+            geometry is valid, and "#ff3333" if invalid.
         """
-        return """<circle
-            cx="{0.x}"
-            cy="{0.y}"
-            r="{1}"
-            stroke="#555555"
-            stroke-width="{2}"
-            fill="{3}"
-            opacity=".6"
-            />""".format(
-                self,
-                3 * scale_factor,
-                1 * scale_factor,
-                "#66cc99" if self.is_valid else "#ff3333")
+        if self.is_empty:
+            return '<g />'
+        if fill_color is None:
+            fill_color = "#66cc99" if self.is_valid else "#ff3333"
+        return (
+            '<circle cx="{0.x}" cy="{0.y}" r="{1}" '
+            'stroke="#555555" stroke-width="{2}" fill="{3}" opacity="0.6" />'
+            ).format(self, 3. * scale_factor, 1. * scale_factor, fill_color)
 
     @property
     def ctypes(self):

{Shapely-1.5.5 → Shapely-1.5.7}/shapely/geometry/polygon.py

@@ -300,25 +300,33 @@ class Polygon(BaseGeometry):
             'coordinates': tuple(coords)
             }
 
-    def svg(self, scale_factor=1.):
-        """
-        SVG representation of the geometry. Scale factor is multiplied by
-        the size of the SVG symbol so it can be scaled consistently for a
-        consistent appearance based on the canvas size.
+    def svg(self, scale_factor=1., fill_color=None):
+        """Returns SVG path element for the Polygon geometry.
+
+        Parameters
+        ==========
+        scale_factor : float
+            Multiplication factor for the SVG stroke-width.  Default is 1.
+        fill_color : str, optional
+            Hex string for fill color. Default is to use "#66cc99" if
+            geometry is valid, and "#ff3333" if invalid.
         """
-        exterior_coords = [["{0},{1}".format(*c) for c in self.exterior.coords]]
+        if self.is_empty:
+            return '<g />'
+        if fill_color is None:
+            fill_color = "#66cc99" if self.is_valid else "#ff3333"
+        exterior_coords = [
+            ["{0},{1}".format(*c) for c in self.exterior.coords]]
         interior_coords = [
             ["{0},{1}".format(*c) for c in interior.coords]
-            for interior in self.interiors ]
+            for interior in self.interiors]
         path = " ".join([
             "M {0} L {1} z".format(coords[0], " L ".join(coords[1:]))
-            for coords in exterior_coords + interior_coords ])
-        return """
-            <g fill-rule="evenodd" fill="{2}" stroke="#555555"
-            stroke-width="{0}" opacity="0.6">
-            <path d="{1}" />
-            </g>""".format(
-                2.*scale_factor, path, "#66cc99" if self.is_valid else "#ff3333")
+            for coords in exterior_coords + interior_coords])
+        return (
+            '<path fill-rule="evenodd" fill="{2}" stroke="#555555" '
+            'stroke-width="{0}" opacity="0.6" d="{1}" />'
+            ).format(2. * scale_factor, path, fill_color)
 
 
 class PolygonAdapter(PolygonProxy, Polygon):

{Shapely-1.5.5 → Shapely-1.5.7}/shapely/geos.py

@@ -8,7 +8,8 @@ import sys
 import atexit
 import logging
 import threading
-from ctypes import CDLL, cdll, pointer, c_void_p, c_size_t, c_char_p, string_at
+from ctypes import CDLL, cdll, pointer, string_at, cast, POINTER
+from ctypes import c_void_p, c_size_t, c_char_p, c_int, c_float
 from ctypes.util import find_library
 
 from . import ftools
@@ -184,19 +185,33 @@ class TopologicalError(Exception):
 class PredicateError(Exception):
     pass
 
-
-def error_handler(fmt, *args):
-    if sys.version_info[0] >= 3:
+# While this function can take any number of positional arguments when
+# called from Python and GEOS expects its error handler to accept any
+# number of arguments (like printf), I'm unable to get ctypes to make
+# a callback object from this function that will accept any number of
+# arguments.
+#
+# At the moment, functions in the GEOS C API only pass 0 or 1 arguments
+# to the error handler. We can deal with this, but when if that changes,
+# Shapely may break.
+
+def handler(level):
+    def callback(fmt, *args):
         fmt = fmt.decode('ascii')
-        args = [arg.decode('ascii') for arg in args]
-    LOG.error(fmt, *args)
-
-
-def notice_handler(fmt, args):
-    if sys.version_info[0] >= 3:
-        fmt = fmt.decode('ascii')
-        args = args.decode('ascii')
-    LOG.warning(fmt, args)
+        conversions = re.findall(r'%.', fmt)
+        log_vals = []
+        for spec, arg in zip(conversions, args):
+            if spec == '%s' and arg is not None:
+                log_vals.append(string_at(arg).decode('ascii'))
+            else:
+                LOG.error("An error occurred, but the format string "
+                          "'%s' could not be converted.", fmt)
+                return
+        getattr(LOG, level)(fmt, *log_vals)
+    return callback
+
+error_handler = handler('error')
+notice_handler = handler('warning')
 
 error_h = EXCEPTION_HANDLER_FUNCTYPE(error_handler)
 notice_h = EXCEPTION_HANDLER_FUNCTYPE(notice_handler)