bin2path 0.1.0__py3-none-any.whl

bin2path/visualize.py

@@ -0,0 +1,380 @@
+"""Visualize a 3D path."""
+
+from bin2path.path import Path3D
+from bin2path.orient import infer_dirs_from_path
+import matplotlib.pyplot as plt
+import matplotlib.patches as mpatches
+from mpl_toolkits.mplot3d import Axes3D  # noqa: F401  # needed for 3d projection
+import numpy as np
+from typing import Optional, Dict
+
+
+def visualize(
+    path: Path3D,
+    figsize: tuple[float, float] = (12, 10),
+    show_vertices: bool = True,
+    vertex_size: float = 30,
+    vertex_color: str = "#FF5733",
+    show_edges: bool = True,
+    edge_color: str = "#2E86AB",
+    edge_linewidth: float = 2.8,
+    min_edge_linewidth: float = 1.8,
+    edge_outline: bool = True,
+    edge_outline_color: Optional[str] = None,
+    edge_outline_width: float = 1.6,
+    show_start: bool = True,
+    start_color: str = "#28A745",
+    start_size: float = 100,
+    show_end: bool = True,
+    end_color: str = "#DC3545",
+    end_size: float = 100,
+    axis_equal: bool = True,
+    hide_axes: bool = False,
+    center: bool = False,
+    normalize: bool = False,
+    color_by_z: bool = True,
+    color_by_step: bool = True,
+    show_cube: bool = False,
+    auto_view: bool = False,
+    dark_theme: bool = False,
+    highlight_nodes: bool = True,
+    title: Optional[str] = None,
+    azim: float = -60,
+    elev: float = 30,
+    save_path: Optional[str] = None,
+) -> None:
+    """
+    Visualize a 3D path.
+    
+    Args:
+        path: Path3D object to visualize.
+        figsize: Figure size (width, height).
+        show_vertices: Whether to show vertex markers.
+        vertex_size: Size of vertex markers.
+        vertex_color: Color of vertices.
+        show_edges: Whether to show edge lines.
+        edge_color: Color of edges.
+        edge_linewidth: Width of edge lines.
+        show_start: Whether to highlight start point.
+        start_color: Color of start point.
+        start_size: Size of start point marker.
+        show_end: Whether to highlight end point.
+        end_color: Color of end point.
+        end_size: Size of end point marker.
+        axis_equal: Whether to set equal axis scaling (before centering/normalizing).
+        hide_axes: If True, hide axes, ticks and grid (show pure figure).
+        center: If True, center vertices around origin before plotting.
+        normalize: If True, scale vertices to fit into [-1,1] cube.
+        color_by_z: If True, color vertices by their Z coordinate (depth cue).
+        color_by_step: If True, color edges by step type (L/R/U/D).
+        show_cube: If True, draw a wireframe cube around normalized figure.
+        title: Optional title for the plot.
+        azim: Azimuth angle for 3D view.
+        elev: Elevation angle for 3D view.
+        save_path: Optional path to save the figure.
+    """
+    fig = plt.figure(figsize=figsize)
+    ax = fig.add_subplot(111, projection="3d")
+
+    # optional dark background for лучшего 3D-эффекта
+    if dark_theme:
+        fig.patch.set_facecolor("black")
+        ax.set_facecolor("black")
+        # на тёмном фоне тонкие линии хуже читаются
+        edge_linewidth *= 1.25
+        min_edge_linewidth *= 1.25
+
+    # outline settings (auto-contrast if color not provided)
+    if edge_outline_color is None:
+        edge_outline_color = "#FFFFFF" if dark_theme else "#000000"
+    
+    # raw integer vertices for direction classification (L/R/U/D)
+    raw_vertices = np.array(path.vertices, dtype=float)
+    # working copy (may be centered/normalized for plotting)
+    vertices = raw_vertices.copy()
+
+    # Optional centering / normalization (to view figure "out of axes")
+    if center or normalize:
+        cx, cy, cz = vertices.mean(axis=0)
+        vertices[:, 0] -= cx
+        vertices[:, 1] -= cy
+        vertices[:, 2] -= cz
+
+        if normalize:
+            span = np.max(np.ptp(vertices, axis=0))  # max range among axes
+            if span > 0:
+                vertices /= span
+    
+    # подготовка диапазона Z для глубинных эффектов
+    z_min = z_max = None
+    z_span = None
+    if len(vertices) > 0:
+        zs_all = vertices[:, 2]
+        z_min = float(zs_all.min())
+        z_max = float(zs_all.max())
+        z_span = z_max - z_min or 1.0
+
+    if show_edges and len(path.edges) > 0:
+        # Draw edges as lines, optionally colored by step type (L/R/U/D)
+        if color_by_step:
+            step_colors: Dict[str, str] = {
+                "L": "#FF5733",  # orange/red
+                "R": "#2E86AB",  # blue
+                "U": "#28A745",  # green
+                "D": "#FFC300",  # yellow
+            }
+            dirs = infer_dirs_from_path(path.vertices, path.edges)
+            for i, (from_idx, to_idx) in enumerate(path.edges):
+                sym = dirs[i] if i < len(dirs) else None
+                c = step_colors.get(sym or "", edge_color)
+                # draw using transformed vertices for correct placement
+                from_plot = vertices[from_idx]
+                to_plot = vertices[to_idx]
+                # простая глубинная подсветка по Z: ближе — толще и ярче
+                if z_span is not None:
+                    z_mid = 0.5 * (from_plot[2] + to_plot[2])
+                    depth_factor = 0.45 + 0.55 * ((z_mid - z_min) / z_span)
+                else:
+                    depth_factor = 1.0
+                ax.plot(
+                    [from_plot[0], to_plot[0]],
+                    [from_plot[1], to_plot[1]],
+                    [from_plot[2], to_plot[2]],
+                    color=edge_outline_color if edge_outline else c,
+                    linewidth=(
+                        max(min_edge_linewidth, edge_linewidth * depth_factor)
+                        + (edge_outline_width if edge_outline else 0.0)
+                    ),
+                    alpha=(0.75 + 0.25 * depth_factor) if edge_outline else (0.65 + 0.35 * depth_factor),
+                    solid_capstyle="round",
+                    solid_joinstyle="round",
+                    antialiased=True,
+                )
+                if edge_outline:
+                    ax.plot(
+                        [from_plot[0], to_plot[0]],
+                        [from_plot[1], to_plot[1]],
+                        [from_plot[2], to_plot[2]],
+                        color=c,
+                        linewidth=max(min_edge_linewidth, edge_linewidth * depth_factor),
+                        alpha=0.65 + 0.35 * depth_factor,
+                        solid_capstyle="round",
+                        solid_joinstyle="round",
+                        antialiased=True,
+                    )
+        else:
+            for from_idx, to_idx in path.edges:
+                from_v = vertices[from_idx]
+                to_v = vertices[to_idx]
+                if z_span is not None:
+                    z_mid = 0.5 * (from_v[2] + to_v[2])
+                    depth_factor = 0.45 + 0.55 * ((z_mid - z_min) / z_span)
+                else:
+                    depth_factor = 1.0
+                ax.plot(
+                    [from_v[0], to_v[0]],
+                    [from_v[1], to_v[1]],
+                    [from_v[2], to_v[2]],
+                    color=edge_outline_color if edge_outline else edge_color,
+                    linewidth=(
+                        max(min_edge_linewidth, edge_linewidth * depth_factor)
+                        + (edge_outline_width if edge_outline else 0.0)
+                    ),
+                    alpha=(0.75 + 0.25 * depth_factor) if edge_outline else (0.65 + 0.35 * depth_factor),
+                    solid_capstyle="round",
+                    solid_joinstyle="round",
+                    antialiased=True,
+                )
+                if edge_outline:
+                    ax.plot(
+                        [from_v[0], to_v[0]],
+                        [from_v[1], to_v[1]],
+                        [from_v[2], to_v[2]],
+                        color=edge_color,
+                        linewidth=max(min_edge_linewidth, edge_linewidth * depth_factor),
+                        alpha=0.65 + 0.35 * depth_factor,
+                        solid_capstyle="round",
+                        solid_joinstyle="round",
+                        antialiased=True,
+                    )
+    
+    if show_vertices:
+        xs, ys, zs = vertices[:, 0], vertices[:, 1], vertices[:, 2]
+        if color_by_z:
+            # Нормализуем Z для цветовой карты, чтобы глубина была видна визуально
+            z_min_s, z_max_s = zs.min(), zs.max()
+            span = z_max_s - z_min_s or 1.0
+            colors = (zs - z_min_s) / span
+            sc = ax.scatter(
+                xs,
+                ys,
+                zs,
+                c=colors,
+                cmap="viridis",
+                s=vertex_size,
+                alpha=0.8,
+                depthshade=True,
+            )
+        else:
+            ax.scatter(
+                xs,
+                ys,
+                zs,
+                c=vertex_color,
+                s=vertex_size,
+                alpha=0.6,
+                depthshade=True,
+            )
+
+    # подсветка "узлов" — вершин, в которые путь входит несколько раз
+    if highlight_nodes and len(vertices) > 0:
+        coords_map: Dict[tuple[float, float, float], int] = {}
+        for vx, vy, vz in vertices:
+            key = (float(vx), float(vy), float(vz))
+            coords_map[key] = coords_map.get(key, 0) + 1
+        node_x, node_y, node_z = [], [], []
+        for (vx, vy, vz), cnt in coords_map.items():
+            if cnt > 1:
+                node_x.append(vx)
+                node_y.append(vy)
+                node_z.append(vz)
+        if node_x:
+            ax.scatter(
+                node_x,
+                node_y,
+                node_z,
+                c="#FFFFFF" if dark_theme else "#8E44AD",
+                s=vertex_size * 1.5,
+                alpha=0.9,
+                marker="o",
+                label="Nodes",
+                depthshade=False,
+            )
+    
+    if show_start and len(vertices) > 0:
+        start = vertices[0]
+        ax.scatter(
+            [start[0]], [start[1]], [start[2]],
+            c=start_color,
+            s=start_size,
+            marker="o",
+            label="Start",
+            depthshade=False,
+        )
+    
+    if show_end and len(vertices) > 1:
+        end = vertices[-1]
+        ax.scatter(
+            [end[0]], [end[1]], [end[2]],
+            c=end_color,
+            s=end_size,
+            marker="s",
+            label="End",
+            depthshade=False,
+        )
+    
+    # Labels and title
+    if not hide_axes:
+        ax.set_xlabel("X")
+        ax.set_ylabel("Y")
+        ax.set_zlabel("Z")
+    
+    if title is None:
+        title = f"bin2path: {path.metadata.original_number} (bits: {path.metadata.bits_length})"
+    ax.set_title(title, fontsize=14, fontweight="bold")
+    
+    # Set viewing angle (with optional авто-подбором)
+    if auto_view and len(vertices) > 1:
+        # грубая эвристика: смотрим так, чтобы был виден и Z, и самые вытянутые оси
+        ranges = np.ptp(vertices, axis=0)
+        # если Z почти плоский, чуть больше сверху
+        if ranges[2] < 0.2 * max(ranges[0], ranges[1]):
+            use_elev, use_azim = 70, 45
+        else:
+            use_elev, use_azim = 30, 45
+        ax.view_init(elev=use_elev, azim=use_azim)
+    else:
+        ax.view_init(elev=elev, azim=azim)
+    
+    # Equal aspect ratio
+    if axis_equal:
+        # Get the max range to set limits
+        max_range = np.max(np.abs(vertices).max(axis=0)) * 1.1
+        ax.set_xlim([-max_range, max_range])
+        ax.set_ylim([-max_range, max_range])
+        ax.set_zlim([-max_range, max_range])
+
+    # Optional wireframe cube to emphasize 3D space
+    if show_cube:
+        r = max_range if axis_equal else np.max(np.abs(vertices).max(axis=0)) * 1.1
+        # 8 cube vertices
+        corners = np.array(
+            [
+                [-r, -r, -r],
+                [r, -r, -r],
+                [r, r, -r],
+                [-r, r, -r],
+                [-r, -r, r],
+                [r, -r, r],
+                [r, r, r],
+                [-r, r, r],
+            ]
+        )
+        # 12 edges of the cube
+        cube_edges = [
+            (0, 1),
+            (1, 2),
+            (2, 3),
+            (3, 0),
+            (4, 5),
+            (5, 6),
+            (6, 7),
+            (7, 4),
+            (0, 4),
+            (1, 5),
+            (2, 6),
+            (3, 7),
+        ]
+        for i0, i1 in cube_edges:
+            p0, p1 = corners[i0], corners[i1]
+            ax.plot(
+                [p0[0], p1[0]],
+                [p0[1], p1[1]],
+                [p0[2], p1[2]],
+                color="#CCCCCC",
+                linewidth=0.5,
+                alpha=0.5,
+            )
+    
+    # Add legend: Start/End + step type colors
+    handles = []
+    if show_start:
+        handles.append(mpatches.Patch(color=start_color, label="Start"))
+    if show_end:
+        handles.append(mpatches.Patch(color=end_color, label="End"))
+
+    if color_by_step:
+        # Same colors as in edge rendering
+        handles.extend(
+            [
+                mpatches.Patch(color="#FF5733", label="L (Left)"),
+                mpatches.Patch(color="#2E86AB", label="R (Right)"),
+                mpatches.Patch(color="#28A745", label="U (Up)"),
+                mpatches.Patch(color="#FFC300", label="D (Down)"),
+            ]
+        )
+
+    if handles:
+        ax.legend(handles=handles, loc="upper left")
+    
+    # Optionally hide axes / ticks / grid
+    if hide_axes:
+        ax.set_axis_off()
+
+    plt.tight_layout()
+    
+    if save_path:
+        plt.savefig(save_path, dpi=150, bbox_inches="tight", facecolor="white")
+        print(f"Figure saved to {save_path}")
+    
+    plt.show()

bin2path-0.1.0.dist-info/METADATA

@@ -0,0 +1,234 @@
+Metadata-Version: 2.4
+Name: bin2path
+Version: 0.1.0
+Summary: Transform numbers into 3D geometric paths - binary visualization
+Author: bin2path
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Sett11/bin2path
+Project-URL: Repository, https://github.com/Sett11/bin2path
+Keywords: binary,3d,visualization,geometry,hashing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: matplotlib>=3.7.0
+Requires-Dist: numpy>=1.24.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: build>=1.2.0; extra == "dev"
+Dynamic: license-file
+
+# bin2path
+
+Transform numbers into 3D geometric paths.
+
+A Python library for converting natural numbers into 3D geometric shapes (spatial polylines on an integer lattice).  
+We use a **cellular-automaton scheme** that produces a sequence of symbolic steps `L/R/U/D`, and then interpret these steps as **local** (orientation-dependent) moves in 3D.
+
+## Concept
+
+Each number is represented as a 3D path on an integer lattice via a **discrete step rule**:
+
+- We work with the binary representation **MSB → LSB** (left-to-right bits).
+- Each bit is mapped to one of 4 **symbols**: `L/R/U/D`.
+- Each symbol is then interpreted as a **relative 3D move** based on the current orientation (`forward/up/right`), so the path is not constrained to a plane.
+
+### Bits → symbols (cellular automaton)
+
+- **First bit**:
+  - `0` → first step `L`
+  - `1` → first step `R`
+- **Each next bit** (only previous step matters):
+  - if bit = `0`:
+    - if previous step was `L` → current step `D`
+    - otherwise → `L`
+  - if bit = `1`:
+    - if previous step was `R` → current step `U`
+    - otherwise → `R`
+
+### Symbols → 3D steps (local orientation)
+
+We maintain a local frame:
+
+- `forward` (where “go forward” points)
+- `up` (local up)
+- `right = cross(forward, up)`
+
+Initial frame:
+
+- `forward = (0, 0, 1)` (along +Z)
+- `up      = (0, 1, 0)` (along +Y)
+
+Step semantics (rotate if needed, then move 1 unit along the new `forward`):
+
+- `R`: move forward
+- `L`: yaw left around `up`, then move forward
+- `U`: pitch up around `right`, then move forward
+- `D`: pitch down around `right`, then move forward
+
+So the path is built from `(0,0,0)` by applying these steps.
+
+The representation is:
+- **Unique**: Different numbers produce different paths
+- **Reversible**: You can decode the path back to the original number
+- **Deterministic**: Same number always produces same path
+
+## Installation
+
+```bash
+pip install bin2path
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/Sett11/bin2path.git
+cd bin2path
+pip install -e .
+```
+
+## Quick Start
+
+```python
+import bin2path
+
+# Encode a number to 3D path
+path = bin2path.encode(42)
+
+# Get path data
+print(path.vertices)    # list of (x,y,z)
+print(path.edges)       # list of (from_idx, to_idx)
+
+# Decode back to number
+number = bin2path.decode(path)  # 42
+
+# Visualize
+bin2path.visualize(path)
+
+# Extract features for clustering / analysis
+f = bin2path.features(path)
+print(f['path_length'])   # number of steps
+print(f['turns'])         # number of direction changes (zeros)
+print(f['straightness'])  # ratio of direct to path distance
+```
+
+### Example: 8 = 1000
+
+```python
+import bin2path
+
+print(bin2path.encode(8).vertices)
+# [(0, 0, 0), (0, 0, 1), (1, 0, 1), (1, -1, 1), (1, -1, 0)]
+```
+
+## API Reference
+
+### Core Functions
+
+- `encode(number: int) -> Path3D` — Convert number to 3D path
+- `decode(path: Path3D) -> int` — Convert path back to number
+- `features(path: Path3D) -> dict` — Extract features for clustering
+- `visualize(path: Path3D, **kwargs)` — Render 3D visualization
+- `serialize(path) -> dict` — Convert to JSON-serializable dict
+- `deserialize(data) -> Path3D` — Restore from dict
+- `to_json(path) -> str` — Convert to JSON string
+- `from_json(json_str) -> Path3D` — Parse JSON string
+- `compare(path1, path2) -> dict` — Compare similarity between paths
+- `validate(path) -> (bool, list[str])` — Validate path correctness
+- `is_valid(path) -> bool` — Quick validity check
+- `batch_encode(numbers) -> list[Path3D]` — Encode multiple numbers
+- `batch_decode(paths) -> list[int]` — Decode multiple paths
+
+### Path3D Structure
+
+```python
+@dataclass
+class Path3D:
+    vertices: list[tuple[int, int, int]]  # [(x,y,z), ...]
+    edges: list[tuple[int, int]]          # [(from_idx, to_idx), ...]
+    metadata: PathMetadata                 # additional info
+
+@dataclass
+class PathMetadata:
+    original_number: int          # original input number
+    bits_length: int             # length of binary representation
+    first_one_pos: int          # position of first 1-bit (MSB index)
+    step_positions: list[int]   # positions of all 1-bits (MSB indices)
+    start_direction: tuple      # starting forward direction (defaults to +Z)
+```
+
+### Features
+
+The `features()` function returns a dictionary with:
+
+- `path_length`: Number of edges/steps
+- `turns`: Approximate number of bit-0 transitions (`bits_length - len(edges)`)
+- `direct_distance`: Straight-line distance from start to end
+- `straightness`: Ratio of direct distance to path length
+- `center_x`, `center_y`, `center_z`: Center of mass coordinates
+- `bbox_x`, `bbox_y`, `bbox_z`: Bounding box dimensions
+- `displacement_x`, `displacement_y`, `displacement_z`: Total displacement
+- `direction_histogram`: Count of steps in ±X/±Y/±Z directions
+- `self_intersections`: Number of vertex revisits
+
+## Examples
+
+### Roundtrip Test
+
+```python
+import bin2path
+
+test_numbers = [0, 1, 2, 42, 100, 12345, 2**10, 999999]
+for n in test_numbers:
+    path = bin2path.encode(n)
+    decoded = bin2path.decode(path)
+    assert decoded == n  # Always True!
+```
+
+### Visualization Options
+
+```python
+import bin2path
+
+path = bin2path.encode(42)
+
+# Basic visualization
+bin2path.visualize(path)
+
+# Custom appearance
+bin2path.visualize(
+    path,
+    figsize=(10, 8),
+    vertex_color="red",
+    edge_color="blue",
+    edge_linewidth=3,
+    vertex_size=50,
+)
+
+# Save to file
+bin2path.visualize(path, save_path="my_path.png")
+
+# Different viewing angle
+bin2path.visualize(path, azim=45, elev=30)
+```
+
+## Requirements
+
+- Python >= 3.10
+- matplotlib >= 3.7.0
+- numpy >= 1.24.0
+
+## License
+
+MIT License
+
+## See Also
+
+See [`plan.md`](plan.md) for the detailed specification of the scheme (including the local-orientation rules).

bin2path-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+bin2path/__init__.py,sha256=627z-Mtlgu21o7m2XkTxZJSzTSv-Tx9QmfrJh1LdR5M,1305
+bin2path/animate.py,sha256=MYQP6CHCkHG5-qJCCH_uWrgNJZfiP8snE2yudvzlRaY,7371
+bin2path/batch.py,sha256=yZkKeIDHDTb4vyM3WAn9PQHXR9w-K2gS9bIk9MXBCWI,850
+bin2path/compare.py,sha256=Aa_kYRrO4V_kjkFssaoesxg_w2S5NJLGnLiSGl2nvgg,4097
+bin2path/decode.py,sha256=Gh9MdUvsHQYTytK85edYlBwm5eoZk4xdvjyOONNIl-Q,899
+bin2path/encode.py,sha256=4ldZzRzw7ZBVtqS2oyWMl4ateRdF3pEGzViueNmCNlU,3909
+bin2path/features.py,sha256=Lpiu_YWjTc8ip77na8hhO0qcuNtUr_IwCAb2PrNAiDM,4472
+bin2path/orient.py,sha256=bYh6XuF_hrg2GKhDrPkwzYB-QdddAVd3_3lA6qxyN0E,3016
+bin2path/path.py,sha256=g6MYUm1pPT6qlRyq9D_4IoJ1W440K1kh8BnmeH2Kzp0,2401
+bin2path/serialize.py,sha256=x4nVXFWp0mIyCzAv7chygJq5xCfCmuLm6trfx5t5qLQ,2611
+bin2path/validate.py,sha256=3SXE8j8q_IIkfcaRQisl1tIObqo0eLRAtrTmjhahzRE,3350
+bin2path/visualize.py,sha256=WVmyKwQo3S3C0IZTnDac40cU2TZXr1DGPaMh78IwRcI,13911
+bin2path-0.1.0.dist-info/licenses/LICENSE,sha256=fhQbkSI0Ns-8wXuiGbFGIHWgr4YvtU8tf7oafdrNI_s,1078
+bin2path-0.1.0.dist-info/METADATA,sha256=VuJwrYYRN7WmINXggk8LaHIVKd9QCD6H_-wv9yyXCv4,7007
+bin2path-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+bin2path-0.1.0.dist-info/top_level.txt,sha256=6UZrteOSkVzQO-noNNRUnsn7fEZmaH8IubrI0LTgAwc,9
+bin2path-0.1.0.dist-info/RECORD,,

bin2path-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bin2path-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 bin2path contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bin2path-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bin2path