squarify 0.4.2__tar.gz → 0.4.4__tar.gz

squarify-0.4.4/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright 2013 Uri Laserson
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

squarify-0.4.4/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: squarify
+Version: 0.4.4
+Summary: Pure Python implementation of the squarify treemap layout algorithm
+Home-page: https://github.com/laserson/squarify
+Author: Uri Laserson
+Author-email: uri.laserson@gmail.com
+License: Apache License 2.0
+Keywords: treemap visualization squarify layout graphics
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+License-File: LICENSE.txt

squarify-0.4.4/README.md

@@ -0,0 +1,219 @@
+squarify
+========
+![](https://img.shields.io/pypi/v/squarify.svg?style=flat)
+![](https://github.com/laserson/squarify/actions/workflows/python-package.yml/badge.svg)
+![](https://img.shields.io/pypi/pyversions/squarify.svg?style=flat)
+![](https://img.shields.io/pypi/l/squarify.svg?style=flat)
+
+Pure Python implementation of the squarify treemap layout algorithm.
+
+Based on algorithm from [Bruls, Huizing, van Wijk, "Squarified Treemaps"](https://doi.org/10.1007/978-3-7091-6783-0_4), but
+implements it differently.
+
+## Contents
+
+* [Installation](#Installation)
+* [Usage](#Usage)
+* [Example](#Example)
+* [Documentation](#Documentation-for-Squarify)
+
+Installation
+------------
+
+Compatible with Python 2 and Python 3.
+
+    pip install squarify
+
+
+Usage
+-----
+
+The main function is `squarify` and it requires two things:
+
+* A coordinate system comprising values for the origin (`x` and `y`) and the
+width/height (`dx` and `dy`).
+* A list of positive values sorted from largest to smallest and normalized to
+the total area, i.e., `dx * dy`).
+
+The function returns a list of `dict`s (i.e., JSON objects), each one a
+rectangle with coordinates corresponding to the given coordinate system and area
+proportional to the corresponding value.  Here's an example rectangle:
+
+```json
+{
+    "x": 0.0,
+    "y": 0.0,
+    "dx": 327.7,
+    "dy": 433.0
+}
+```
+
+The rectangles can be easily plotted using, for example,
+[d3.js](http://d3js.org/).
+
+There is also a version of `squarify` called `padded_squarify` that returns
+rectangles that, when laid out, have a bit of padding to show their borders.
+
+The helper function `normalize_sizes` will compute the normalized values, and
+the helper function `plot` will generate a Matplotlib-based treemap
+visualization of your data (see [documentation](#Documentation-for-Squarify)).
+
+
+Example
+-------
+```python
+import squarify
+
+# these values define the coordinate system for the returned rectangles
+# the values will range from x to x + width and y to y + height
+x = 0.
+y = 0.
+width = 700.
+height = 433.
+
+values = [500, 433, 78, 25, 25, 7]
+
+# values must be sorted descending (and positive, obviously)
+values.sort(reverse=True)
+
+# the sum of the values must equal the total area to be laid out
+# i.e., sum(values) == width * height
+values = squarify.normalize_sizes(values, width, height)
+
+# returns a list of rectangles
+rects = squarify.squarify(values, x, y, width, height)
+
+# padded rectangles will probably visualize better for certain cases
+padded_rects = squarify.padded_squarify(values, x, y, width, height)
+```
+
+The variable `rects` contains
+
+```json
+[
+  {
+    "dy": 433,
+    "dx": 327.7153558052434,
+    "x": 0,
+    "y": 0
+  },
+  {
+    "dy": 330.0862676056338,
+    "dx": 372.2846441947566,
+    "x": 327.7153558052434,
+    "y": 0
+  },
+  {
+    "dy": 102.9137323943662,
+    "dx": 215.0977944236371,
+    "x": 327.7153558052434,
+    "y": 330.0862676056338
+  },
+  {
+    "dy": 102.9137323943662,
+    "dx": 68.94160077680677,
+    "x": 542.8131502288805,
+    "y": 330.0862676056338
+  },
+  {
+    "dy": 80.40135343309854,
+    "dx": 88.24524899431273,
+    "x": 611.7547510056874,
+    "y": 330.0862676056338
+  },
+  {
+    "dy": 22.51237896126767,
+    "dx": 88.2452489943124,
+    "x": 611.7547510056874,
+    "y": 410.4876210387323
+  }
+]
+```
+
+Documentation for [Squarify](squarify/__init__.py)
+---------
+
+`normalize_sizes(sizes, dx, dy)`
+:   Normalize list of values.
+
+Normalizes a list of numeric values so that `sum(sizes) == dx * dy`.
+
+**Parameters**
+
+    sizes : list-like of numeric values
+        Input list of numeric values to normalize.
+    dx, dy : numeric
+        The dimensions of the full rectangle to normalize total values to.
+
+    Returns
+    -------
+    list[numeric]
+        The normalized values.
+
+----------------------------------------------------------------------------------------
+
+`padded_squarify(sizes, x, y, dx, dy)`
+:   Compute padded treemap rectangles.
+
+See `squarify` docstring for details. The only difference is that the
+returned rectangles have been "padded" to allow for a visible border.
+
+----------------------------------------------------------------------------------------
+
+`plot(sizes, norm_x=100, norm_y=100, color=None, label=None, value=None, ax=None, pad=False, bar_kwargs=None, text_kwargs=None, **kwargs)`
+:   Plotting with Matplotlib.
+
+**Parameters**
+
+    sizes
+        input for squarify
+    norm_x, norm_y
+        x and y values for normalization
+    color
+        color string or list-like (see Matplotlib documentation for details)
+    label
+        list-like used as label text
+    value
+        list-like used as value text (in most cases identical with sizes argument)
+    ax
+        Matplotlib Axes instance
+    pad
+        draw rectangles with a small gap between them
+    bar_kwargs : dict
+        keyword arguments passed to matplotlib.Axes.bar
+    text_kwargs : dict
+        keyword arguments passed to matplotlib.Axes.text
+    **kwargs
+        Any additional kwargs are merged into `bar_kwargs`. Explicitly provided
+        kwargs here will take precedence.
+
+**Returns**
+
+    matplotlib.axes.Axes
+        Matplotlib Axes
+
+----------------------------------------------------------------------------------------
+
+`squarify(sizes, x, y, dx, dy)`
+:   Compute treemap rectangles.
+
+Given a set of values, computes a treemap layout in the specified geometry
+using an algorithm based on Bruls, Huizing, van Wijk, "Squarified Treemaps".
+See README for example usage.
+
+**Parameters**
+
+    sizes : list-like of numeric values
+        The set of values to compute a treemap for. `sizes` must be positive
+        values sorted in descending order and they should be normalized to the
+        total area (i.e., `dx * dy == sum(sizes)`)
+    x, y : numeric
+        The coordinates of the "origin".
+    dx, dy : numeric
+        The full width (`dx`) and height (`dy`) of the treemap.
+
+**Returns**
+
+    list[dict]
+        Each dict in the returned list represents a single rectangle in the
+        treemap. The order corresponds to the input order.

{squarify-0.4.2 → squarify-0.4.4}/setup.py

@@ -2,18 +2,19 @@ from setuptools import setup
 
 setup(
     name="squarify",
-    version="0.4.2",
+    version="0.4.4",
     packages=["squarify"],
     author="Uri Laserson",
     author_email="uri.laserson@gmail.com",
     description="Pure Python implementation of the squarify treemap layout algorithm",
-    license="Apache v2",
+    license="Apache License 2.0",
     keywords="treemap visualization squarify layout graphics",
     classifiers=[
-        "Programming Language :: Python :: 2.6",
-        "Programming Language :: Python :: 2.7",
-        "Programming Language :: Python :: 3.5",
-        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
     ],
     url="https://github.com/laserson/squarify",
 )

{squarify-0.4.2 → squarify-0.4.4}/squarify/__init__.py

@@ -182,6 +182,7 @@ def plot(
     label=None,
     value=None,
     ax=None,
+    pad=False,
     bar_kwargs=None,
     text_kwargs=None,
     **kwargs
@@ -202,8 +203,8 @@ def plot(
         list-like used as value text (in most cases identical with sizes argument)
     ax
         Matplotlib Axes instance
-    label
-        fontsize of the labels
+    pad
+        draw rectangles with a small gap between them
     bar_kwargs : dict
         keyword arguments passed to matplotlib.Axes.bar
     text_kwargs : dict
@@ -238,7 +239,11 @@ def plot(
         bar_kwargs.update(kwargs)
 
     normed = normalize_sizes(sizes, norm_x, norm_y)
-    rects = squarify(normed, 0, 0, norm_x, norm_y)
+
+    if pad:
+        rects = padded_squarify(normed, 0, 0, norm_x, norm_y)
+    else:
+        rects = squarify(normed, 0, 0, norm_x, norm_y)
 
     x = [rect["x"] for rect in rects]
     y = [rect["y"] for rect in rects]
@@ -249,14 +254,14 @@ def plot(
         x, dy, width=dx, bottom=y, color=color, label=label, align="edge", **bar_kwargs
     )
 
-    if not value is None:
+    if value is not None:
         va = "center" if label is None else "top"
 
         for v, r in zip(value, rects):
             x, y, dx, dy = r["x"], r["y"], r["dx"], r["dy"]
             ax.text(x + dx / 2, y + dy / 2, v, va=va, ha="center", **text_kwargs)
 
-    if not label is None:
+    if label is not None:
         va = "center" if value is None else "bottom"
         for l, r in zip(label, rects):
             x, y, dx, dy = r["x"], r["y"], r["dx"], r["dy"]

squarify-0.4.4/squarify.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: squarify
+Version: 0.4.4
+Summary: Pure Python implementation of the squarify treemap layout algorithm
+Home-page: https://github.com/laserson/squarify
+Author: Uri Laserson
+Author-email: uri.laserson@gmail.com
+License: Apache License 2.0
+Keywords: treemap visualization squarify layout graphics
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+License-File: LICENSE.txt

{squarify-0.4.2 → squarify-0.4.4}/squarify.egg-info/SOURCES.txt

@@ -1,7 +1,9 @@
+LICENSE.txt
 README.md
 setup.py
 squarify/__init__.py
 squarify.egg-info/PKG-INFO
 squarify.egg-info/SOURCES.txt
 squarify.egg-info/dependency_links.txt
-squarify.egg-info/top_level.txt
+squarify.egg-info/top_level.txt
+tests/test_squarify.py

squarify-0.4.4/tests/test_squarify.py

@@ -0,0 +1,49 @@
+from squarify import normalize_sizes, squarify
+
+
+expected = [
+    {"dy": 433, "dx": 327.7153558052434, "x": 0, "y": 0},
+    {"dy": 330.0862676056338, "dx": 372.2846441947566, "x": 327.7153558052434, "y": 0},
+    {
+        "dy": 102.9137323943662,
+        "dx": 215.0977944236371,
+        "x": 327.7153558052434,
+        "y": 330.0862676056338,
+    },
+    {
+        "dy": 102.9137323943662,
+        "dx": 68.94160077680677,
+        "x": 542.8131502288805,
+        "y": 330.0862676056338,
+    },
+    {
+        "dy": 80.40135343309854,
+        "dx": 88.24524899431273,
+        "x": 611.7547510056874,
+        "y": 330.0862676056338,
+    },
+    {
+        "dy": 22.51237896126767,
+        "dx": 88.2452489943124,
+        "x": 611.7547510056874,
+        "y": 410.4876210387323,
+    },
+]
+
+
+def test_squarify():
+    x = 0.0
+    y = 0.0
+    width = 700.0
+    height = 433.0
+    values = [500, 433, 78, 25, 25, 7]
+    values = normalize_sizes(values, width, height)
+    observed = squarify(values, x, y, width, height)
+    assert len(observed) == len(expected)
+    for (o, e) in zip(observed, expected):
+        assert len(o) == 4
+        assert set(o.keys()) == set(["dx", "dy", "x", "y"])
+        assert o["dx"] == e["dx"]
+        assert o["dy"] == e["dy"]
+        assert o["x"] == e["x"]
+        assert o["y"] == e["y"]

squarify-0.4.2/PKG-INFO

@@ -1,15 +0,0 @@
-Metadata-Version: 1.1
-Name: squarify
-Version: 0.4.2
-Summary: Pure Python implementation of the squarify treemap layout algorithm
-Home-page: https://github.com/laserson/squarify
-Author: Uri Laserson
-Author-email: uri.laserson@gmail.com
-License: Apache v2
-Description: UNKNOWN
-Keywords: treemap visualization squarify layout graphics
-Platform: UNKNOWN
-Classifier: Programming Language :: Python :: 2.6
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6

squarify-0.4.2/README.md

@@ -1,124 +0,0 @@
-squarify
-========
-![](https://img.shields.io/pypi/v/squarify.svg?style=flat)
-[![Build Status](https://travis-ci.org/laserson/squarify.svg?branch=master)](https://travis-ci.org/laserson/squarify)
-![](https://img.shields.io/pypi/pyversions/squarify.svg?style=flat)
-![](https://img.shields.io/pypi/l/squarify.svg?style=flat)
-
-Pure Python implementation of the squarify treemap layout algorithm.
-
-Based on algorithm from [Bruls, Huizing, van Wijk, "Squarified Treemaps"](https://doi.org/10.1007/978-3-7091-6783-0_4), but
-implements it differently.
-
-Installation
-------------
-
-Compatible with Python 2 and Python 3.
-
-    pip install squarify
-
-
-Usage
------
-
-The main function is `squarify` and it requires two things:
-
-* A coordinate system comprising values for the origin (`x` and `y`) and the
-width/height (`dx` and `dy`).
-* A list of positive values sorted from largest to smallest and normalized to
-the total area, i.e., `dx * dy`).
-
-The function returns a list of `dict`s (i.e., JSON objects), each one a
-rectangle with coordinates corresponding to the given coordinate system and area
-proportional to the corresponding value.  Here's an example rectangle:
-
-```json
-{
-    "x": 0.0,
-    "y": 0.0,
-    "dx": 327.7,
-    "dy": 433.0
-}
-```
-
-The rectangles can be easily plotted using, for example,
-[d3.js](http://d3js.org/).
-
-There is also a version of `squarify` called `padded_squarify` that returns
-rectangles that, when laid out, have a bit of padding to show their borders.
-
-The helper function `normalize_sizes` will compute the normalized values, and
-the helper function `plot` will generate a Matplotlib-based treemap
-visualization of your data (see docstring).
-
-
-Example
--------
-```python
-import squarify
-
-# these values define the coordinate system for the returned rectangles
-# the values will range from x to x + width and y to y + height
-x = 0.
-y = 0.
-width = 700.
-height = 433.
-
-values = [500, 433, 78, 25, 25, 7]
-
-# values must be sorted descending (and positive, obviously)
-values.sort(reverse=True)
-
-# the sum of the values must equal the total area to be laid out
-# i.e., sum(values) == width * height
-values = squarify.normalize_sizes(values, width, height)
-
-# returns a list of rectangles
-rects = squarify.squarify(values, x, y, width, height)
-
-# padded rectangles will probably visualize better for certain cases
-padded_rects = squarify.padded_squarify(values, x, y, width, height)
-```
-
-The variable `rects` contains
-
-```json
-[
-  {
-    "dy": 433,
-    "dx": 327.7153558052434,
-    "x": 0,
-    "y": 0
-  },
-  {
-    "dy": 330.0862676056338,
-    "dx": 372.2846441947566,
-    "x": 327.7153558052434,
-    "y": 0
-  },
-  {
-    "dy": 102.9137323943662,
-    "dx": 215.0977944236371,
-    "x": 327.7153558052434,
-    "y": 330.0862676056338
-  },
-  {
-    "dy": 102.9137323943662,
-    "dx": 68.94160077680677,
-    "x": 542.8131502288805,
-    "y": 330.0862676056338
-  },
-  {
-    "dy": 80.40135343309854,
-    "dx": 88.24524899431273,
-    "x": 611.7547510056874,
-    "y": 330.0862676056338
-  },
-  {
-    "dy": 22.51237896126767,
-    "dx": 88.2452489943124,
-    "x": 611.7547510056874,
-    "y": 410.4876210387323
-  }
-]
-```

squarify-0.4.2/squarify.egg-info/PKG-INFO

@@ -1,15 +0,0 @@
-Metadata-Version: 1.1
-Name: squarify
-Version: 0.4.2
-Summary: Pure Python implementation of the squarify treemap layout algorithm
-Home-page: https://github.com/laserson/squarify
-Author: Uri Laserson
-Author-email: uri.laserson@gmail.com
-License: Apache v2
-Description: UNKNOWN
-Keywords: treemap visualization squarify layout graphics
-Platform: UNKNOWN
-Classifier: Programming Language :: Python :: 2.6
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6