perspective-python 4.2.0__cp311-abi3-win_amd64.whl

perspective/tests/conftest.py

@@ -0,0 +1,272 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+#  ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+#  ┃ This file is part of the Perspective library, distributed under the terms ┃
+#  ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+#  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+from datetime import datetime, date
+
+import numpy as np
+import pandas as pd
+import pyarrow as pa
+from pytest import fixture
+from random import random, randint, choice
+from faker import Faker
+
+
+# Our tests construct naive datetimes everywhere
+# so setting it here is an easy way to fix it globally.
+import os
+
+# Perspective used to support datetime.date and datetime.datetime
+# as Table() constructor arguments, but now we forward the parameters
+# directly to JSON.loads. So to make sure the tests dont need to be
+# so utterly transmogrified, we have this little hack :)
+import json
+
+
+os.environ["TZ"] = "UTC"
+
+
+def new_encoder(self, obj):
+    if isinstance(obj, datetime):
+        return str(obj)
+    elif isinstance(obj, date):
+        return str(obj)
+    else:
+        return old(self, obj)
+
+
+old = json.JSONEncoder.default
+json.JSONEncoder.default = new_encoder
+
+fake = Faker()
+
+
+def _make_date_time_index(size, time_unit):
+    return pd.date_range("2000-01-01", periods=size, freq=time_unit)
+
+
+def _make_period_index(size, time_unit):
+    return pd.period_range(start="2000", periods=size, freq=time_unit)
+
+
+def _make_dataframe(index, size=10):
+    """Create a new random dataframe of `size` and with a DateTimeIndex of
+    frequency `time_unit`.
+    """
+    return pd.DataFrame(
+        index=index,
+        data={
+            "a": np.random.rand(size),
+            "b": np.random.rand(size),
+            "c": np.random.rand(size),
+            "d": np.random.rand(size),
+        },
+    )
+
+
+class Util:
+    @staticmethod
+    def make_arrow(names, data, types=None, legacy=False):
+        """Create an arrow binary that can be loaded and manipulated from memory.
+
+        Args:
+            names (list): a list of str column names
+            data (list): a list of lists containing data for each column
+            types (list): an optional list of `pyarrow.type` function references.
+                Types will be inferred if not provided.
+            legacy (bool): if True, use legacy IPC format (pre-pyarrow 0.15). Defaults to False.
+
+        Returns:
+            bytes : a bytes object containing the arrow-serialized output.
+        """
+        stream = pa.BufferOutputStream()
+        arrays = []
+
+        for idx, column in enumerate(data):
+            # only apply types if array is present
+            kwargs = {}
+            if types:
+                kwargs["type"] = types[idx]
+            arrays.append(pa.array(column, **kwargs))
+
+        batch = pa.RecordBatch.from_arrays(arrays, names)
+        table = pa.Table.from_batches([batch])
+        writer = pa.RecordBatchStreamWriter(
+            stream, table.schema
+        )
+
+        writer.write_table(table)
+        writer.close()
+        return stream.getvalue().to_pybytes()
+
+    @staticmethod
+    def make_arrow_from_pandas(df, schema=None, legacy=False):
+        """Create an arrow binary from a Pandas dataframe.
+
+        Args:
+            df (:obj:`pandas.DataFrame`)
+            schema (:obj:`pyarrow.Schema`)
+            legacy (bool): if True, use legacy IPC format (pre-pyarrow 0.15). Defaults to False.
+
+        Returns:
+            bytes : a bytes object containing the arrow-serialized output.
+        """
+        stream = pa.BufferOutputStream()
+        table = pa.Table.from_pandas(df, schema=schema)
+
+        writer = pa.RecordBatchStreamWriter(
+            stream, table.schema
+        )
+
+        writer.write_table(table)
+        writer.close()
+        return stream.getvalue().to_pybytes()
+
+    @staticmethod
+    def make_dictionary_arrow(names, data, types=None, legacy=False):
+        """Create an arrow binary that can be loaded and manipulated from memory, with
+        each column being a dictionary array of `str` values and `int` indices.
+
+        Args:
+            names (list): a list of str column names
+            data (list:tuple): a list of tuples, the first value being a list of indices,
+                and the second value being a list of values.
+            types (list:list:pyarrow.func): a list of lists, containing the indices type and
+                dictionary value type for each array.
+            legacy (bool): if True, use legacy IPC format (pre-pyarrow 0.15). Defaults to False.
+
+        Returns:
+            bytes : a bytes object containing the arrow-serialized output.
+        """
+        stream = pa.BufferOutputStream()
+
+        arrays = []
+        for idx, column in enumerate(data):
+            indice_type = pa.int64()
+            value_type = pa.string()
+
+            if types is not None:
+                indice_type = types[idx][0]
+                value_type = types[idx][1]
+
+            indices = pa.array(column[0], type=indice_type)
+            values = pa.array(column[1], type=value_type)
+            parray = pa.DictionaryArray.from_arrays(indices, values)
+            arrays.append(parray)
+
+        batch = pa.RecordBatch.from_arrays(arrays, names)
+        table = pa.Table.from_batches([batch])
+        writer = pa.RecordBatchStreamWriter(
+            stream, table.schema
+        )
+
+        writer.write_table(table)
+        writer.close()
+        return stream.getvalue().to_pybytes()
+
+    @staticmethod
+    def to_timestamp(obj):
+        """Return an integer timestamp based on a date/datetime object."""
+        classname = obj.__class__.__name__
+        if classname == "date":
+            return int(datetime(obj.year, obj.month, obj.day).timestamp() * 1000)
+        elif classname == "datetime":
+            return int(obj.timestamp() * 1000)
+        else:
+            return -1
+
+    @staticmethod
+    def make_dataframe(size=10, freq="D"):
+        index = _make_date_time_index(size, freq)
+        return _make_dataframe(index, size)
+
+    @staticmethod
+    def make_period_dataframe(size=10):
+        index = _make_period_index(size, "M")
+        return _make_dataframe(index, size)
+
+    @staticmethod
+    def make_series(size=10, freq="D"):
+        index = _make_date_time_index(size, freq)
+        return pd.Series(data=np.random.rand(size), index=index)
+
+
+class Sentinel(object):
+    """Generic sentinel class for testing side-effectful code in Python 2 and
+    3.
+    """
+
+    def __init__(self, value):
+        self.value = value
+
+    def get(self):
+        return self.value
+
+    def set(self, new_value):
+        self.value = new_value
+
+
+@fixture()
+def sentinel():
+    """Pass `sentinel` into a test and call it with `value` to create a new
+    instance of the Sentinel class.
+
+    Example:
+        >>> def test_with_sentinel(self, sentinel):
+        >>>    s = sentinel(True)
+        >>>    s.set(False)
+        >>>    s.get()  # returns False
+    """
+
+    def _sentinel(value):
+        return Sentinel(value)
+
+    return _sentinel
+
+
+@fixture
+def util():
+    """Pass the `Util` class in to a test."""
+    return Util
+
+
+@fixture
+def superstore(count=100):
+    data = []
+    for id in range(count):
+        dat = {}
+        dat["Row ID"] = id
+        dat["Order ID"] = "{}-{}".format(fake.ein(), fake.zipcode())
+        dat["Order Date"] = fake.date_this_year()
+        dat["Ship Date"] = fake.date_between_dates(dat["Order Date"]).strftime(
+            "%Y-%m-%d"
+        )
+        dat["Order Date"] = dat["Order Date"].strftime("%Y-%m-%d")
+        dat["Ship Mode"] = choice(["First Class", "Standard Class", "Second Class"])
+        dat["Ship Mode"] = choice(["First Class", "Standard Class", "Second Class"])
+        dat["Customer ID"] = fake.zipcode()
+        dat["Segment"] = choice(["A", "B", "C", "D"])
+        dat["Country"] = "US"
+        dat["City"] = fake.city()
+        dat["State"] = fake.state()
+        dat["Postal Code"] = fake.zipcode()
+        dat["Region"] = choice(["Region %d" % i for i in range(5)])
+        dat["Product ID"] = fake.bban()
+        sector = choice(["Industrials", "Technology", "Financials"])
+        industry = choice(["A", "B", "C"])
+        dat["Category"] = sector
+        dat["Sub-Category"] = industry
+        dat["Sales"] = randint(1, 100) * 100
+        dat["Quantity"] = randint(1, 100) * 10
+        dat["Discount"] = round(random() * 100, 2)
+        dat["Profit"] = round(random() * 1000, 2)
+        data.append(dat)
+    return pd.DataFrame(data)

perspective/tests/core/__init__.py

@@ -0,0 +1,11 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+#  ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+#  ┃ This file is part of the Perspective library, distributed under the terms ┃
+#  ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+#  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

perspective/tests/core/test_async.py

@@ -0,0 +1,351 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+#  ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+#  ┃ This file is part of the Perspective library, distributed under the terms ┃
+#  ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+#  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+import queue
+import random
+import threading
+from functools import partial
+import tornado
+
+from perspective import (
+    Server,
+    Client,
+)
+from pytest import mark
+
+
+def syncify(f):
+    """Given a function `f` that must be run on `TestAsync.loop`, queue `f` on
+    the loop, block until it is evaluated, and return the result.
+    """
+    sem = queue.Queue()
+
+    def _syncify_task():
+        assert threading.current_thread().ident == TestAsync.thread.ident
+        result = f()
+        TestAsync.loop.add_callback(lambda: sem.put(result))
+
+    def _syncify():
+        TestAsync.loop.add_callback(_syncify_task)
+        return sem.get()
+
+    return _syncify
+
+
+data = [{"a": i, "b": i * 0.5, "c": str(i)} for i in range(10)]
+
+
+class TestAsync(object):
+    @classmethod
+    def setup_class(cls):
+        import asyncio
+
+        # Storing the current loop, which was set up by the pytest-asyncio
+        # tests running in tests/async, delays its cleanup, which foregoes a
+        # pytest exception about an unclosed socket.  A cleaner way to fix this
+        # probably exists (use an event loop fixture? convert these tests to
+        # pytest-asyncio?)
+        cls.save_old_loop_to_prevent_unclosed_socket_exception = (
+            asyncio.get_event_loop()
+        )
+        asyncio.set_event_loop(asyncio.new_event_loop())
+        cls.loop = tornado.ioloop.IOLoop.current()
+        cls.thread = threading.Thread(target=cls.loop.start)
+        cls.thread.daemon = True
+        cls.thread.start()
+
+    @classmethod
+    def teardown_class(cls):
+        cls.loop.add_callback(lambda: tornado.ioloop.IOLoop.current().stop())
+        cls.thread.join()
+        cls.loop.close(all_fds=True)
+
+    @classmethod
+    def loop_is_running(cls):
+        return cls.loop.asyncio_loop.is_running()
+
+    def test_async_queue_process(self):
+        server = Server()
+        client = Client.from_server(
+            server,
+        )
+
+        tbl = client.table({"a": "integer", "b": "float", "c": "string"})
+
+        @syncify
+        def _task():
+            assert tbl.size() == 0
+            for i in range(5):
+                tbl.update([data[i]])
+            return tbl.size()
+
+        assert _task() == 5
+        tbl.delete()
+
+    def test_async_queue_process_csv(self):
+        """Make sure GIL release during CSV loading works"""
+        server = Server()
+        client = Client.from_server(
+            server,
+        )
+        tbl = client.table("x,y,z\n1,a,true\n2,b,false\n3,c,true\n4,d,false")
+
+        @syncify
+        def _task():
+            assert tbl.size() == 4
+            for i in range(5):
+                tbl.update("x,y,z\n1,a,true\n2,b,false\n3,c,true\n4,d,false")
+            return tbl.size()
+
+        assert _task() == 24
+
+        tbl.delete()
+
+    def test_async_call_loop(self):
+        server = Server()
+        client = Client.from_server(
+            server,
+        )
+        tbl = client.table({"a": "integer", "b": "float", "c": "string"})
+        tbl.update(data)
+
+        @syncify
+        def _task():
+            return tbl.size()
+
+        assert _task() == 10
+        tbl.delete()
+
+    def test_async_multiple_managers_queue_process(self):
+        server = Server()
+        client = Client.from_server(server)
+        server2 = Server()
+        client2 = Client.from_server(server2)
+        tbl = client.table({"a": "integer", "b": "float", "c": "string"})
+        tbl2 = client2.table({"a": "integer", "b": "float", "c": "string"})
+
+        @syncify
+        def _update_task():
+            for i in range(5):
+                tbl.update([data[i]])
+                tbl2.update([data[i]])
+            return tbl.size()
+
+        assert _update_task() == 5
+
+        @syncify
+        def _flush_to_process():
+            view = tbl2.view()
+            records = view.to_records()
+            for i in range(5):
+                tbl2.update([data[i]])
+
+            view.delete()
+            return records
+
+        assert _flush_to_process() == data[:5]
+
+        @syncify
+        def _delete_task():
+            tbl2.delete()
+            tbl.delete()
+
+        _delete_task()
+
+    @mark.skip(
+        reason="This test is failing because we're not calling process after each update like before"
+    )
+    def test_async_multiple_managers_mixed_queue_process(self):
+        sentinel = {"called": 0}
+
+        def sync_queue_process(f, *args, **kwargs):
+            sentinel["called"] += 1
+            f(*args, **kwargs)
+
+        server = Server()
+        client = Client.from_server(server)
+
+        server2 = Server()
+        client2 = Client.from_server(server2)
+        tbl = client.table({"a": "integer", "b": "float", "c": "string"})
+        tbl2 = client2.table({"a": "integer", "b": "float", "c": "string"})
+
+        @syncify
+        def _tbl_task():
+            for i in range(5):
+                tbl.update([data[i]])
+            return tbl.size()
+
+        assert _tbl_task() == 5
+
+        for i in range(5):
+            tbl2.update([data[i]])
+
+        assert sentinel["called"] == 5
+
+        @syncify
+        def _tbl_task2():
+            view = tbl.view()
+            records = view.to_records()
+            view.delete()
+            tbl.delete()
+            return records
+
+        assert _tbl_task2() == data[:5]
+
+        view = tbl2.view()
+        assert view.to_records() == data[:5]
+
+        view.delete()
+        tbl2.delete()
+
+    @mark.skip(
+        reason="This test is failing because we're not calling process after each update like before"
+    )
+    def test_async_multiple_managers_delayed_process(self):
+        sentinel = {"async": 0, "sync": 0}
+
+        def _counter(key, f, *args, **kwargs):
+            sentinel[key] += 1
+            return f(*args, **kwargs)
+
+        short_delay_queue_process = partial(_counter, "sync")
+        long_delay_queue_process = partial(
+            TestAsync.loop.add_timeout, 1, _counter, "async"
+        )
+
+        server = Server(on_poll_request=short_delay_queue_process)
+        client = Client.from_server(server)
+
+        server2 = Server(on_poll_request=long_delay_queue_process)
+        client2 = Client.from_server(server2)
+        tbl = client.table({"a": "integer", "b": "float", "c": "string"})
+        tbl2 = client2.table({"a": "integer", "b": "float", "c": "string"})
+
+        @syncify
+        def _tbl_task():
+            for i in range(10):
+                tbl2.update([data[i]])
+
+        _tbl_task()
+        for i in range(10):
+            tbl.update([data[i]])
+
+        @syncify
+        def _tbl_task2():
+            size = tbl2.size()
+            tbl2.delete()
+            return size
+
+        assert _tbl_task2() == 10
+        assert tbl.size() == 10
+        assert sentinel["async"] == 1
+        assert sentinel["sync"] == 10
+
+        tbl.delete()
+
+    def test_async_single_manager_tables_chained(self):
+        def call_loop(fn, *args):
+            TestAsync.loop.add_callback(fn, *args)
+
+        server = Server()
+        client = Client.from_server(server)
+        columns = {"index": "integer", "num1": "integer", "num2": "integer"}
+        # tbl = client.table(columns, index="index")
+        tbl = client.table(columns)
+        view = tbl.view()
+        tbl2 = client.table(view.to_arrow())
+
+        def _update(port_id, delta):
+            print("Updating tbl2", delta)
+            tbl2.update(delta)
+
+        view.on_update(_update, mode="row")
+        for i in range(1000):
+            call_loop(tbl.update, [{"index": i, "num1": i, "num2": 2 * i}])
+            i += 1
+
+        call_loop(tbl.size)
+
+        q = queue.Queue()
+        call_loop(q.put, True)
+        q.get()
+
+        @syncify
+        def _tbl_task2():
+            size = tbl2.size()
+            return size
+
+        assert _tbl_task2() == 1000
+        # assert tbl2.size() == 1000
+        view.delete()
+        tbl.delete()
+        tbl2.delete()
+
+    def test_async_queue_process_multiple_ports(self):
+        server = Server()
+        client = Client.from_server(server)
+        tbl = client.table({"a": "integer", "b": "float", "c": "string"})
+        port_ids = [0]
+        port_data = [{"a": 0, "b": 0, "c": "0"}]
+
+        for i in range(10):
+            port_id = tbl.make_port()
+            port_ids.append(port_id)
+            port_data.append({"a": port_id, "b": port_id * 1.5, "c": str(port_id)})
+
+        assert port_ids == list(range(0, 11))
+
+        assert syncify(lambda: tbl.size())() == 0
+
+        random.shuffle(port_ids)
+
+        @syncify
+        def _tbl_task():
+            for port_id in port_ids:
+                idx = port_id if port_id < len(port_ids) else len(port_ids) - 1
+                tbl.update([port_data[idx]], port_id=port_id)
+            size = tbl.size()
+            tbl.delete()
+            return size
+
+        assert len(port_ids) == 11
+        assert _tbl_task() == 11
+
+    def test_async_multiple_managers_queue_process_multiple_ports(self):
+        server = Server()
+        client = Client.from_server(server)
+
+        server2 = Server()
+        client2 = Client.from_server(server2)
+        tbl = client.table({"a": "integer", "b": "float", "c": "string"})
+        tbl2 = client2.table({"a": "integer", "b": "float", "c": "string"})
+        port_ids = [0]
+        port_data = [{"a": 0, "b": 0, "c": "0"}]
+
+        for i in range(10):
+            port_id = tbl.make_port()
+            port_id2 = tbl2.make_port()
+            assert port_id == port_id2
+            port_ids.append(port_id)
+            port_data.append({"a": port_id, "b": port_id * 1.5, "c": str(port_id)})
+
+        @syncify
+        def _task():
+            random.shuffle(port_ids)
+            for port_id in port_ids:
+                idx = port_id if port_id < len(port_ids) else len(port_ids) - 1
+                tbl.update([port_data[idx]], port_id=port_id)
+                tbl2.update([port_data[idx]], port_id=port_id)
+            return (tbl.size(), tbl2.size())
+
+        assert _task() == (11, 11)

perspective/tests/multi_threaded/__init__.py

@@ -0,0 +1,11 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+#  ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+#  ┃ This file is part of the Perspective library, distributed under the terms ┃
+#  ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+#  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛