offset-poly 0.3.3__tar.gz → 0.4.0__tar.gz

{offset_poly-0.3.3/src/offset_poly.egg-info → offset_poly-0.4.0}/PKG-INFO

@@ -1,128 +1,134 @@
-Metadata-Version: 2.1
-Name: offset_poly
-Version: 0.3.3
-Summary: offset a polyline or polygon in 2d space
-Author-email: Shay Hill <shay_public@hotmail.com>
-License: MIT
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-Requires-Dist: vec2_math
-Provides-Extra: dev
-Requires-Dist: commitizen; extra == "dev"
-Requires-Dist: pre-commit; extra == "dev"
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: tox; extra == "dev"
-
-# offset_poly
-
-Move a polyline or polygon (left) by a given offset.
-
-A counterclockwise polygon will be offset to the inside. I clockwise polygon will be offset to the outside.
-
-## offset_polygon
-
-~~~python
-def offset_polygon(polyline: Sequence[_Vec2], offset: float) -> list[_Vec2]:
-    """Offset polygon edges (to the left) by a constant amount.
-
-    :param polyline: polyline
-    :param offset: distance to offset from each edge
-    :return: polygon offset by offset
-    """
-~~~
-
-## offset_polyline
-
-~~~python
-def offset_polyline(polyline: Sequence[_Vec2], offset: float) -> list[_Vec2]:
-    """Offset polygon edges (to the left) by a constant amount.
-
-    :param polyline: polyline
-    :param offset: distance to offset from each edge
-    :return: polyline offset by offset
-    """
-~~~
-
-
-The difference between the two is that `offset_polygon` will close the polygon if it is not already closed, whereas `offset_polyline` will leave the polyline open even if the first and last points are identical.
-
-This package is the simplest version of polyline offsetting, it does not anticipate or account for self intersections that may come up when offsetting a polyline.
-
-This is not nearly as sophisticated as curve offsetting, but you can use this for control polygon offsetting, which will be nearly as good in some instances.
-
-* multiple points (knots in your control points) are preserved.
-* if input[0] == input[-1], output[0] will equal output[-1]
-
-## You may see (nan, nan) in the result.
-
-If you pass two adjacent, opposite, parallel edges, you will get a (nan, nan) in the result. With points A -> B -> A, for instance, there is no point that would be any given distance (except 0) left of both A B and B A.
-
-## More complex functions
-
-There are a few more complex functions,`offset_poly_per_vert` and `offset_poly_per_edge`
-
-~~~python
-def gap_corner(
-    pnt_a: _Vec, pnt_b: _Vec, pnt_c: _Vec, gap_1: float, gap_2: float | None = None
-) -> GapCorner:
-    """Offset a corner (to the left) defined by three points.
-
-    :param pnt_a: previous  point
-    :param pnt_b: corner point
-    :param pnt_c: next point
-    :param gap_1: distance to offset from vec12
-    :param gap_2: optional distance to offset from vec23. If not given, gap_1 is used
-    :return: the unique point gap_1 distance from ab and gap_2 distance from bc
-    :raise ValueError: if angle abc is zero and gap_1 != gap_2
-    """
-~~~
-
-~~~python
-def offset_poly_per_vert(
-    polyline: Sequence[_Vec2],
-    vert_offsets: Iterable[tuple[float, float]],
-    poly_type: PolyType,
-) -> list[GapCorner]:
-    """Offset each corner of a polyline or polygon.
-
-    :param polyline: polyline
-    :param vert_offsets: iterable of (gap_1, gap_2) tuples. One pair per corner.
-    :param poly_type: PolyType.POLYGON or PolyType.POLYLINE
-    :return: polyline offset by vert_offsets
-    :raise ValueError: if fewer than three points are given for a polygon
-    :raise ValueError: if fewer than two points are given for a polyline
-
-    This is the engine of the offset_polyline and offset_polygon
-    functions. You can use it directly, but it's going to be tricky if
-    you have zero-length segments or closed points. These points will
-    be removed before the gaps are applied, so you'll have to pass
-    exactly enough for gap pairs for the segments that are retained.
-    """
-~~~
-
-~~~python
-def offset_poly_per_edge(
-    polyline: Sequence[_Vec2], edge_offsets: Iterable[float], poly_type: PolyType
-) -> list[GapCorner]:
-    """Offset each edge of a polyline or polygon.
-
-    :param polyline: polyline
-    :param edge_offsets: iterable of offsets. One per edge.
-    :param poly_type: PolyType.POLYGON or PolyType.POLYLINE
-    :return: polyline offset by edge_offsets
-
-    This function allows each edge of a polygon or polyline to be offset by
-    a different amount. You will end up with a ValueError in gap_corner
-    if you try to offset consecutive, parallel edges by different amounts.
-    """
-~~~
-
-These allow a little more control, like putting in a different offset for each edge
-
-## return value
-
-The return value will be a GapCorner instance or a list of GapCorner instances. These have three attributes:
-
-* .xsect -> a point at each corner where segment ab offset to the left by gap_1 intersects segment bc offset to the left by gap_2.
-* .angle -> the signed ccw angle at corner abc
-* .cpts -> quadratic Bezier control points for a rounded corner at abc. There is more than one way to handle this when gap_1 != gap_2, but these should give a good result in most situations.
+Metadata-Version: 2.4
+Name: offset-poly
+Version: 0.4.0
+Summary: offset a polyline or polygon in 2d space
+Author: Shay Hill
+Author-email: Shay Hill <shay_public@hotmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Dist: vec2-math
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# offset_poly
+
+Move a polyline or polygon (left) by a given offset.
+
+A counterclockwise polygon will be offset to the inside. I clockwise polygon will be offset to the outside.
+
+## offset_polygon
+
+~~~python
+def offset_polygon(polyline: Sequence[_Vec2], offset: float) -> list[_Vec2]:
+    """Offset polygon edges (to the left) by a constant amount.
+
+    :param polyline: polyline
+    :param offset: distance to offset from each edge
+    :return: polygon offset by offset
+    """
+~~~
+
+## offset_polyline
+
+~~~python
+def offset_polyline(polyline: Sequence[_Vec2], offset: float) -> list[_Vec2]:
+    """Offset polygon edges (to the left) by a constant amount.
+
+    :param polyline: polyline
+    :param offset: distance to offset from each edge
+    :return: polyline offset by offset
+    """
+~~~
+
+
+The difference between the two is that `offset_polygon` will close the polygon if it is not already closed, whereas `offset_polyline` will leave the polyline open even if the first and last points are identical.
+
+This package is the simplest version of polyline offsetting, it does not anticipate or account for self intersections that may come up when offsetting a polyline.
+
+This is not nearly as sophisticated as curve offsetting, but you can use this for control polygon offsetting, which will be nearly as good in some instances.
+
+* multiple points (knots in your control points) are preserved.
+* if input[0] == input[-1], output[0] will equal output[-1]
+
+## You may see (nan, nan) in the result.
+
+If you pass two adjacent, opposite, parallel edges, you will get a (nan, nan) in the result. With points A -> B -> A, for instance, there is no point that would be any given distance (except 0) left of both A B and B A.
+
+## More complex functions
+
+There are a few more complex functions,`offset_poly_per_vert` and `offset_poly_per_edge`
+
+~~~python
+def gap_corner(
+    pnt_a: _Vec, pnt_b: _Vec, pnt_c: _Vec, gap_1: float, gap_2: float | None = None
+) -> GapCorner:
+    """Offset a corner (to the left) defined by three points.
+
+    :param pnt_a: previous  point
+    :param pnt_b: corner point
+    :param pnt_c: next point
+    :param gap_1: distance to offset from vec12
+    :param gap_2: optional distance to offset from vec23. If not given, gap_1 is used
+    :return: the unique point gap_1 distance from ab and gap_2 distance from bc
+    :raise ValueError: if angle abc is zero and gap_1 != gap_2
+    """
+~~~
+
+~~~python
+def offset_poly_per_vert(
+    polyline: Sequence[_Vec2],
+    vert_offsets: Iterable[tuple[float, float]],
+    poly_type: PolyType,
+) -> list[GapCorner]:
+    """Offset each corner of a polyline or polygon.
+
+    :param polyline: polyline
+    :param vert_offsets: iterable of (gap_1, gap_2) tuples. One pair per corner.
+    :param poly_type: PolyType.POLYGON or PolyType.POLYLINE
+    :return: polyline offset by vert_offsets
+    :raise ValueError: if fewer than three points are given for a polygon
+    :raise ValueError: if fewer than two points are given for a polyline
+
+    This is the engine of the offset_polyline and offset_polygon
+    functions. You can use it directly, but it's going to be tricky if
+    you have zero-length segments or closed points. These points will
+    be removed before the gaps are applied, so you'll have to pass
+    exactly enough for gap pairs for the segments that are retained.
+    """
+~~~
+
+~~~python
+def offset_poly_per_edge(
+    polyline: Sequence[_Vec2], edge_offsets: Iterable[float], poly_type: PolyType
+) -> list[GapCorner]:
+    """Offset each edge of a polyline or polygon.
+
+    :param polyline: polyline
+    :param edge_offsets: iterable of offsets. One per edge.
+    :param poly_type: PolyType.POLYGON or PolyType.POLYLINE
+    :return: polyline offset by edge_offsets
+
+    This function allows each edge of a polygon or polyline to be offset by
+    a different amount. You will end up with a ValueError in gap_corner
+    if you try to offset consecutive, parallel edges by different amounts.
+    """
+~~~
+
+These allow a little more control, like putting in a different offset for each edge
+
+## return value
+
+The return value will be a GapCorner instance or a list of GapCorner instances. These have three attributes:
+
+* .xsect -> a point at each corner where segment ab offset to the left by gap_1 intersects segment bc offset to the left by gap_2.
+* .angle -> the signed ccw angle at corner abc
+* .cpts -> quadratic Bezier control points for a rounded corner at abc. There is more than one way to handle this when gap_1 != gap_2, but these should give a good result in most situations.

{offset_poly-0.3.3 → offset_poly-0.4.0}/README.md

@@ -1,113 +1,113 @@
-# offset_poly
-
-Move a polyline or polygon (left) by a given offset.
-
-A counterclockwise polygon will be offset to the inside. I clockwise polygon will be offset to the outside.
-
-## offset_polygon
-
-~~~python
-def offset_polygon(polyline: Sequence[_Vec2], offset: float) -> list[_Vec2]:
-    """Offset polygon edges (to the left) by a constant amount.
-
-    :param polyline: polyline
-    :param offset: distance to offset from each edge
-    :return: polygon offset by offset
-    """
-~~~
-
-## offset_polyline
-
-~~~python
-def offset_polyline(polyline: Sequence[_Vec2], offset: float) -> list[_Vec2]:
-    """Offset polygon edges (to the left) by a constant amount.
-
-    :param polyline: polyline
-    :param offset: distance to offset from each edge
-    :return: polyline offset by offset
-    """
-~~~
-
-
-The difference between the two is that `offset_polygon` will close the polygon if it is not already closed, whereas `offset_polyline` will leave the polyline open even if the first and last points are identical.
-
-This package is the simplest version of polyline offsetting, it does not anticipate or account for self intersections that may come up when offsetting a polyline.
-
-This is not nearly as sophisticated as curve offsetting, but you can use this for control polygon offsetting, which will be nearly as good in some instances.
-
-* multiple points (knots in your control points) are preserved.
-* if input[0] == input[-1], output[0] will equal output[-1]
-
-## You may see (nan, nan) in the result.
-
-If you pass two adjacent, opposite, parallel edges, you will get a (nan, nan) in the result. With points A -> B -> A, for instance, there is no point that would be any given distance (except 0) left of both A B and B A.
-
-## More complex functions
-
-There are a few more complex functions,`offset_poly_per_vert` and `offset_poly_per_edge`
-
-~~~python
-def gap_corner(
-    pnt_a: _Vec, pnt_b: _Vec, pnt_c: _Vec, gap_1: float, gap_2: float | None = None
-) -> GapCorner:
-    """Offset a corner (to the left) defined by three points.
-
-    :param pnt_a: previous  point
-    :param pnt_b: corner point
-    :param pnt_c: next point
-    :param gap_1: distance to offset from vec12
-    :param gap_2: optional distance to offset from vec23. If not given, gap_1 is used
-    :return: the unique point gap_1 distance from ab and gap_2 distance from bc
-    :raise ValueError: if angle abc is zero and gap_1 != gap_2
-    """
-~~~
-
-~~~python
-def offset_poly_per_vert(
-    polyline: Sequence[_Vec2],
-    vert_offsets: Iterable[tuple[float, float]],
-    poly_type: PolyType,
-) -> list[GapCorner]:
-    """Offset each corner of a polyline or polygon.
-
-    :param polyline: polyline
-    :param vert_offsets: iterable of (gap_1, gap_2) tuples. One pair per corner.
-    :param poly_type: PolyType.POLYGON or PolyType.POLYLINE
-    :return: polyline offset by vert_offsets
-    :raise ValueError: if fewer than three points are given for a polygon
-    :raise ValueError: if fewer than two points are given for a polyline
-
-    This is the engine of the offset_polyline and offset_polygon
-    functions. You can use it directly, but it's going to be tricky if
-    you have zero-length segments or closed points. These points will
-    be removed before the gaps are applied, so you'll have to pass
-    exactly enough for gap pairs for the segments that are retained.
-    """
-~~~
-
-~~~python
-def offset_poly_per_edge(
-    polyline: Sequence[_Vec2], edge_offsets: Iterable[float], poly_type: PolyType
-) -> list[GapCorner]:
-    """Offset each edge of a polyline or polygon.
-
-    :param polyline: polyline
-    :param edge_offsets: iterable of offsets. One per edge.
-    :param poly_type: PolyType.POLYGON or PolyType.POLYLINE
-    :return: polyline offset by edge_offsets
-
-    This function allows each edge of a polygon or polyline to be offset by
-    a different amount. You will end up with a ValueError in gap_corner
-    if you try to offset consecutive, parallel edges by different amounts.
-    """
-~~~
-
-These allow a little more control, like putting in a different offset for each edge
-
-## return value
-
-The return value will be a GapCorner instance or a list of GapCorner instances. These have three attributes:
-
-* .xsect -> a point at each corner where segment ab offset to the left by gap_1 intersects segment bc offset to the left by gap_2.
-* .angle -> the signed ccw angle at corner abc
-* .cpts -> quadratic Bezier control points for a rounded corner at abc. There is more than one way to handle this when gap_1 != gap_2, but these should give a good result in most situations.
+# offset_poly
+
+Move a polyline or polygon (left) by a given offset.
+
+A counterclockwise polygon will be offset to the inside. I clockwise polygon will be offset to the outside.
+
+## offset_polygon
+
+~~~python
+def offset_polygon(polyline: Sequence[_Vec2], offset: float) -> list[_Vec2]:
+    """Offset polygon edges (to the left) by a constant amount.
+
+    :param polyline: polyline
+    :param offset: distance to offset from each edge
+    :return: polygon offset by offset
+    """
+~~~
+
+## offset_polyline
+
+~~~python
+def offset_polyline(polyline: Sequence[_Vec2], offset: float) -> list[_Vec2]:
+    """Offset polygon edges (to the left) by a constant amount.
+
+    :param polyline: polyline
+    :param offset: distance to offset from each edge
+    :return: polyline offset by offset
+    """
+~~~
+
+
+The difference between the two is that `offset_polygon` will close the polygon if it is not already closed, whereas `offset_polyline` will leave the polyline open even if the first and last points are identical.
+
+This package is the simplest version of polyline offsetting, it does not anticipate or account for self intersections that may come up when offsetting a polyline.
+
+This is not nearly as sophisticated as curve offsetting, but you can use this for control polygon offsetting, which will be nearly as good in some instances.
+
+* multiple points (knots in your control points) are preserved.
+* if input[0] == input[-1], output[0] will equal output[-1]
+
+## You may see (nan, nan) in the result.
+
+If you pass two adjacent, opposite, parallel edges, you will get a (nan, nan) in the result. With points A -> B -> A, for instance, there is no point that would be any given distance (except 0) left of both A B and B A.
+
+## More complex functions
+
+There are a few more complex functions,`offset_poly_per_vert` and `offset_poly_per_edge`
+
+~~~python
+def gap_corner(
+    pnt_a: _Vec, pnt_b: _Vec, pnt_c: _Vec, gap_1: float, gap_2: float | None = None
+) -> GapCorner:
+    """Offset a corner (to the left) defined by three points.
+
+    :param pnt_a: previous  point
+    :param pnt_b: corner point
+    :param pnt_c: next point
+    :param gap_1: distance to offset from vec12
+    :param gap_2: optional distance to offset from vec23. If not given, gap_1 is used
+    :return: the unique point gap_1 distance from ab and gap_2 distance from bc
+    :raise ValueError: if angle abc is zero and gap_1 != gap_2
+    """
+~~~
+
+~~~python
+def offset_poly_per_vert(
+    polyline: Sequence[_Vec2],
+    vert_offsets: Iterable[tuple[float, float]],
+    poly_type: PolyType,
+) -> list[GapCorner]:
+    """Offset each corner of a polyline or polygon.
+
+    :param polyline: polyline
+    :param vert_offsets: iterable of (gap_1, gap_2) tuples. One pair per corner.
+    :param poly_type: PolyType.POLYGON or PolyType.POLYLINE
+    :return: polyline offset by vert_offsets
+    :raise ValueError: if fewer than three points are given for a polygon
+    :raise ValueError: if fewer than two points are given for a polyline
+
+    This is the engine of the offset_polyline and offset_polygon
+    functions. You can use it directly, but it's going to be tricky if
+    you have zero-length segments or closed points. These points will
+    be removed before the gaps are applied, so you'll have to pass
+    exactly enough for gap pairs for the segments that are retained.
+    """
+~~~
+
+~~~python
+def offset_poly_per_edge(
+    polyline: Sequence[_Vec2], edge_offsets: Iterable[float], poly_type: PolyType
+) -> list[GapCorner]:
+    """Offset each edge of a polyline or polygon.
+
+    :param polyline: polyline
+    :param edge_offsets: iterable of offsets. One per edge.
+    :param poly_type: PolyType.POLYGON or PolyType.POLYLINE
+    :return: polyline offset by edge_offsets
+
+    This function allows each edge of a polygon or polyline to be offset by
+    a different amount. You will end up with a ValueError in gap_corner
+    if you try to offset consecutive, parallel edges by different amounts.
+    """
+~~~
+
+These allow a little more control, like putting in a different offset for each edge
+
+## return value
+
+The return value will be a GapCorner instance or a list of GapCorner instances. These have three attributes:
+
+* .xsect -> a point at each corner where segment ab offset to the left by gap_1 intersects segment bc offset to the left by gap_2.
+* .angle -> the signed ccw angle at corner abc
+* .cpts -> quadratic Bezier control points for a rounded corner at abc. There is more than one way to handle this when gap_1 != gap_2, but these should give a good result in most situations.

offset_poly-0.4.0/pyproject.toml

@@ -0,0 +1,112 @@
+[project]
+name = "offset-poly"
+version = "0.4.0"
+description = "offset a polyline or polygon in 2d space"
+readme = "README.md"
+license = "MIT"
+authors = [
+    { name = "Shay Hill", email = "shay_public@hotmail.com" }
+]
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Typing :: Typed",
+]
+dependencies = ["vec2_math"]
+
+[build-system]
+requires = ["uv_build>=0.11.25,<0.12.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "commitizen>=4.16.5",
+    "pre-commit>=4.6.1",
+    "pytest>=9.1.1",
+]
+
+
+[tool.commitizen]
+name = "cz_conventional_commits"
+version = "0.4.0"
+tag_format = "$version"
+major-version-zero = true
+version_files = ["pyproject.toml:^version"]
+
+
+[tool.isort]
+profile = "black"
+
+
+[tool.pytest.ini_options]
+addopts = "--doctest-modules"
+pythonpath = "tests"
+testpaths = ["tests"]
+log_cli = true
+
+
+[tool.ruff]
+target-version = "py310"
+exclude = ["typings", ".venv"]
+[tool.ruff.lint.pydocstyle]
+convention = "pep257"
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*.py" = [
+    "S101",
+    "D",
+    "F401",
+] # Ignore assertions, docstrings, unused imports in test files
+
+[tool.ruff.format]
+docstring-code-line-length = 88
+skip-magic-trailing-comma = true
+
+[tool.ruff.lint.isort]
+# keep isort consistent with format.skip-magic-trailing-comma
+split-on-trailing-comma = false
+
+[tool.ruff.lint]
+select = ["ALL"]
+# only auto-fix __all__ sorting (RUF022) and import sorting (I)
+fixable = ["RUF022", "I"]
+ignore = [
+    "COM812",  # trailing comma missing (does not agree with Black)
+    "D203",    # 1 blank line before class docstring (incompatible with D211)
+    "D213",    # multi-line summary second line (incompatible with D212)
+    "ISC003",  # explicitly concatenated string should be implicit
+    "FLY",     # Use f-string instead of ...
+    "S311",    # Standard pseudo-random generators are not suitable for security/cryptographic purposes
+    "S301",    # don't use pickle
+]
+
+
+[tool.pyright]
+include = ["src", "tests"]
+exclude = ["**/__pycache__.py"]
+ignore = ["typings", ".venv"]
+
+pythonVersion = "3.10"
+pythonPlatform = "All"
+
+typeCheckingMode = "strict"
+reportCallInDefaultInitializer = true
+reportImplicitStringConcatenation = true
+reportPropertyTypeMismatch = true
+reportUninitializedInstanceVariable = true
+reportUnnecessaryTypeIgnoreComment = true
+reportUnusedCallResult = true
+
+venvPath = "."
+venv = "./.venv"
+
+[[tool.pyright.executionEnvironments]]
+root = "tests"

{offset_poly-0.3.3 → offset_poly-0.4.0}/src/offset_poly/__init__.py

@@ -1,21 +1,21 @@
-"""Import fuctions into the package namespace.
-
-:author: Shay Hill
-:created: 2023-08-19
-"""
-
-from offset_poly.offset import (
-    offset_poly_per_edge,
-    offset_poly_per_vert,
-    offset_polygon,
-    offset_polyline,
-)
-from offset_poly.offset_corner import gap_corner
-
-__all__ = [
-    "gap_corner",
-    "offset_polyline",
-    "offset_polygon",
-    "offset_poly_per_vert",
-    "offset_poly_per_edge",
-]
+"""Import functions into the package namespace.
+
+:author: Shay Hill
+:created: 2023-08-19
+"""
+
+from offset_poly.offset import (
+    offset_poly_per_edge,
+    offset_poly_per_vert,
+    offset_polygon,
+    offset_polyline,
+)
+from offset_poly.offset_corner import gap_corner
+
+__all__ = [
+    "gap_corner",
+    "offset_poly_per_edge",
+    "offset_poly_per_vert",
+    "offset_polygon",
+    "offset_polyline",
+]