datablob 0.8.0__py3-none-any.whl

datablob/__init__.py

@@ -0,0 +1,459 @@
+import boto3
+import csv
+from datetime import datetime
+import geopandas as gpd
+import io
+from json import dumps as json_dumps
+from json import loads as json_loads
+from openpyxl import Workbook
+import os
+import pandas as pd
+import tempfile
+import tzdata
+import zipfile
+from zoneinfo import ZoneInfo
+
+POSSIBLE_LATITUDE_KEYS = [
+    "LATITUDE",
+    "Latitude",
+    "latitude",
+    "LAT",
+    "Lat",
+    "lat",
+    "@lat",
+]
+
+POSSIBLE_LONGITUDE_KEYS = [
+    "LONGITUDE",
+    "Longitude",
+    "longitude",
+    "LONG",
+    "Long",
+    "long",
+    "LON",
+    "Lon",
+    "lon",
+    "@lon",
+]
+
+
+class DataBlobClient:
+    def __init__(self, bucket_name, bucket_path, timezones=None):
+        self.bucket_name = bucket_name
+        self.bucket_path = bucket_path.rstrip("/")
+        self.timezones = timezones or ["UTC"]
+
+    def _get_unique_keys(self, rows):
+        columns = set()
+        for row in rows:
+            columns.update(row.keys())
+        return list(sorted(list(columns)))
+
+    def get_filenames_by_dataset_and_version(self):
+        results = {}
+        response = boto3.client("s3").list_objects_v2(
+            Bucket=self.bucket_name, Prefix=self.bucket_path
+        )
+        if "Contents" in response:
+            for obj in response["Contents"]:
+                key = obj["Key"][len(self.bucket_path) + 1 :]
+
+                if len(key.split("/")) == 3:
+                    [dataset_id, version, filename] = key.split("/")
+                    if version.startswith("v"):
+                        version = version[1:]
+                        if filename:
+                            if dataset_id not in results:
+                                results[dataset_id] = {}
+                            if version not in results[dataset_id]:
+                                results[dataset_id][version] = []
+                            results[dataset_id][version].append(filename)
+
+        for dataset_id, subdict in results.items():
+            versions = list(subdict.keys())
+            for version in versions:
+                files = subdict[version]
+                if "meta.json" in files:
+                    subdict[version] = sorted(subdict[version])
+                else:
+                    del subdict[version]
+        return results
+
+    def upload_csv(self, dataset_name, dataset_version, data):
+        key = (
+            self.bucket_path + "/" + dataset_name + "/v" + dataset_version + "/data.csv"
+        )
+        boto3.client("s3").put_object(
+            Bucket=self.bucket_name,
+            Key=key,
+            Body=data,
+        )
+
+    def upload_tsv(self, dataset_name, dataset_version, data):
+        key = (
+            self.bucket_path + "/" + dataset_name + "/v" + dataset_version + "/data.tsv"
+        )
+        boto3.client("s3").put_object(
+            Bucket=self.bucket_name,
+            Key=key,
+            Body=data,
+        )
+
+    def get_dataset_as_csv(self, name, version, remove_bom=True):
+        key = self.bucket_path + "/" + name + "/v" + version + "/data.csv"
+        response = boto3.client("s3").get_object(Bucket=self.bucket_name, Key=key)
+        object_content = response["Body"].read().decode("utf-8")
+        if remove_bom:
+            object_content = object_content.lstrip("\ufeff")
+        return object_content
+
+    def get_dataset_as_tsv(self, name, version, remove_bom=True):
+        key = self.bucket_path + "/" + name + "/v" + version + "/data.tsv"
+        response = boto3.client("s3").get_object(Bucket=self.bucket_name, Key=key)
+        object_content = response["Body"].read().decode("utf-8")
+        if remove_bom:
+            object_content = object_content.lstrip("\ufeff")
+        return object_content
+
+    def get_dataset_as_json(self, name, version):
+        key = self.bucket_path + "/" + name + "/v" + version + "/data.json"
+        response = boto3.client("s3").get_object(Bucket=self.bucket_name, Key=key)
+        object_content = response["Body"].read().decode("utf-8")
+        return json_loads(object_content)
+
+    def get_dataset_metadata(self, name: str, version: str):
+        key = self.bucket_path + "/" + name + "/v" + version + "/meta.json"
+        response = boto3.client("s3").get_object(Bucket=self.bucket_name, Key=key)
+        object_content = response["Body"].read().decode("utf-8")
+        return json_loads(object_content)
+
+    def upload_geojson_points(self, dataset_name, dataset_version, data):
+        key = (
+            self.bucket_path
+            + "/"
+            + dataset_name
+            + "/v"
+            + dataset_version
+            + "/data.points.geojson"
+        )
+        boto3.client("s3").put_object(
+            Bucket=self.bucket_name,
+            Key=key,
+            Body=data if isinstance(data, str) else json_dumps(data),
+        )
+
+    def upload_shapefile_points(self, dataset_name, dataset_version, blob):
+        key = (
+            self.bucket_path
+            + "/"
+            + dataset_name
+            + "/v"
+            + dataset_version
+            + "/data.points.shp.zip"
+        )
+        boto3.client("s3").put_object(
+            Bucket=self.bucket_name,
+            Key=key,
+            Body=blob,
+        )
+
+    def upload_jsonl(self, dataset_name, dataset_version, data):
+        key = (
+            self.bucket_path
+            + "/"
+            + dataset_name
+            + "/v"
+            + dataset_version
+            + "/data.jsonl"
+        )
+
+        results = ""
+        for row in data:
+            results += json_dumps(row) + "\n"
+
+        boto3.client("s3").put_object(
+            Bucket=self.bucket_name,
+            Key=key,
+            Body=results,
+        )
+
+    def upload_json(self, dataset_name, dataset_version, data):
+        key = (
+            self.bucket_path
+            + "/"
+            + dataset_name
+            + "/v"
+            + dataset_version
+            + "/data.json"
+        )
+        boto3.client("s3").put_object(
+            Bucket=self.bucket_name,
+            Key=key,
+            Body=data if isinstance(data, str) else json_dumps(data),
+        )
+
+    def upload_parquet(self, dataset_name, dataset_version, data):
+        key = (
+            self.bucket_path
+            + "/"
+            + dataset_name
+            + "/v"
+            + dataset_version
+            + "/data.parquet"
+        )
+        boto3.client("s3").put_object(
+            Bucket=self.bucket_name,
+            Key=key,
+            Body=data,
+        )
+
+    def upload_xlsx(self, dataset_name, dataset_version, data):
+        key = (
+            self.bucket_path
+            + "/"
+            + dataset_name
+            + "/v"
+            + dataset_version
+            + "/data.xlsx"
+        )
+        boto3.client("s3").put_object(
+            Bucket=self.bucket_name,
+            Key=key,
+            Body=data,
+        )
+
+    def upload_metadata(self, dataset_name, dataset_version, data):
+        key = (
+            self.bucket_path
+            + "/"
+            + dataset_name
+            + "/v"
+            + dataset_version
+            + "/meta.json"
+        )
+        boto3.client("s3").put_object(
+            Bucket=self.bucket_name,
+            Key=key,
+            Body=data if isinstance(data, str) else json_dumps(data),
+        )
+
+    def convert_gdf_to_shapefile(self, gdf):
+        buf = io.BytesIO()
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = os.path.join(tmpdir, f"data.shp")
+            gdf.to_file(path, driver="ESRI Shapefile")
+
+            # copy temp files into in-memory zip file
+            with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+                for filename in os.listdir(tmpdir):
+                    zf.write(os.path.join(tmpdir, filename), filename)
+
+        buf.seek(0)
+        return buf.getvalue()
+
+    def _convert_row_to_xlsx_data_types(self, row, xlsx_data_types):
+        result = []
+        for icol, value in enumerate(row):
+            data_type = xlsx_data_types[icol]
+            if value is None:
+                value = ""
+            elif data_type == "Number":
+                if value != "":
+                    value = float(value)
+            elif data_type == "Text":
+                value = str(value)
+            else:
+                print("[datablob] warning: unsupported xlsx data type " + data_type)
+                value = str(value)
+            result.append(value)
+        return result
+
+    def convert_to_xlsx(self, meta, data, columns, xlsx_data_types=None):
+        wb = Workbook()
+        ws_overview = wb.active
+        ws_overview.title = "Overview"
+        ws_overview.append(["name", meta["name"]])
+        for tz, value in meta["lastUpdated"].items():
+            ws_overview.append(["last updated (in " + tz + ")", value])
+        ws_overview.append(["description", meta["description"]])
+        ws_overview.append(["number of columns", meta["numColumns"]])
+        ws_overview.append(["number of rows", meta["numRows"]])
+        ws_overview.append(["column names", ", ".join(meta["columns"])])
+        if "xlsx_data_types" in meta:
+            ws_overview.append(["xlsx data types", ", ".join(meta["xlsx_data_types"])])
+
+        # Iterate through all cells in the first column (Column A)
+        max_length = 0
+        for cell in ws_overview["A"]:
+            if cell.value:
+                if len(str(cell.value)) > max_length:
+                    max_length = len(str(cell.value))
+        ws_overview.column_dimensions["A"].width = max_length + 2
+
+        ws_data = wb.create_sheet(title="Data")
+        ws_data.append(columns)
+        for row in data:
+            row = [str(row.get(col, "")) for col in columns]
+            if xlsx_data_types:
+                row = self._convert_row_to_xlsx_data_types(row, xlsx_data_types)
+            ws_data.append(row)
+        xlsx_buffer = io.BytesIO()
+        wb.save(xlsx_buffer)
+        xlsx_buffer.seek(0)
+        return xlsx_buffer
+
+    def convert_rows_to_csv(self, rows, fieldnames=None):
+        f = io.StringIO(newline="")
+        if fieldnames is None:
+            fieldnames = sorted(list(rows[0].keys()))
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(rows)
+        f.seek(0)
+        # read and make sure we don't have a BOM
+        return f.read().lstrip("\ufeff")
+
+    def convert_rows_to_tsv(self, rows, fieldnames=None):
+        f = io.StringIO(newline="")
+        if fieldnames is None:
+            fieldnames = sorted(list(rows[0].keys()))
+        writer = csv.DictWriter(f, fieldnames=fieldnames, delimiter="\t")
+        writer.writeheader()
+        writer.writerows(rows)
+        f.seek(0)
+        # read and make sure we don't have a BOM
+        return f.read().lstrip("\ufeff")
+
+    def infer_latitude(self, rows):
+        keys = POSSIBLE_LATITUDE_KEYS
+        for row in rows:
+            keys = [key for key in keys if key in row]
+        return keys[0] if len(keys) > 1 else None
+
+    def infer_longitude(self, rows):
+        keys = POSSIBLE_LONGITUDE_KEYS
+        for row in rows:
+            keys = [key for key in keys if key in row]
+        return keys[0] if len(keys) > 1 else None
+
+    def convert_rows_to_geojson_points(self, rows, longitude_key, latitude_key):
+        features = []
+        for row in rows:
+            features.append(
+                {
+                    "type": "Feature",
+                    "properties": row,
+                    "geometry": {
+                        "type": "Point",
+                        "coordinates": [row[longitude_key], row[latitude_key]],
+                    },
+                }
+            )
+        return {"type": "FeatureCollection", "features": features}
+
+    def update_dataset(
+        self,
+        name,
+        version,
+        data,
+        column_names=None,
+        description=None,
+        latitude_key=None,
+        longitude_key=None,
+        json=True,
+        jsonl=True,
+        geojson=True,
+        parquet=True,
+        xlsx=False,
+        xlsx_data_types=None,
+    ):
+        lastUpdated = dict(
+            [(tz, datetime.now(ZoneInfo(tz)).isoformat()) for tz in self.timezones]
+        )
+        columns = column_names if column_names else self._get_unique_keys(data)
+        meta = {
+            "name": name,
+            "lastUpdated": lastUpdated,
+            "description": description or "",
+            "numColumns": len(columns),
+            "numRows": len(data),
+            "columns": columns,
+            "files": [],
+        }
+        data_as_csv = self.convert_rows_to_csv(data, fieldnames=columns)
+        data_as_tsv = self.convert_rows_to_tsv(data, fieldnames=columns)
+
+        df = pd.DataFrame(data)
+
+        if latitude_key and longitude_key:
+            if geojson:
+                data_as_geojson_points = self.convert_rows_to_geojson_points(
+                    data, longitude_key=longitude_key, latitude_key=latitude_key
+                )
+            else:
+                data_as_geojson_points = None
+
+            if parquet:
+                gdf = gpd.GeoDataFrame(
+                    df,
+                    geometry=gpd.points_from_xy(df[longitude_key], df[latitude_key]),
+                    crs="EPSG:4326",
+                )
+
+                buffer = io.BytesIO()
+                gdf.to_parquet(buffer, engine="pyarrow")
+                data_as_parquet_blob = buffer.getvalue()
+            else:
+                data_as_parquet_blob = None
+
+            shapefile_blob = self.convert_gdf_to_shapefile(gdf)
+        else:
+            if parquet:
+                buffer = io.BytesIO()
+                df.to_parquet(buffer, engine="pyarrow")
+                data_as_parquet_blob = buffer.getvalue()
+            else:
+                data_as_parquet_blob = None
+
+            data_as_geojson_points = None
+            shapefile_blob = None
+
+        if xlsx:
+            if xlsx_data_types:
+                meta["xlsx_data_types"] = xlsx_data_types
+            data_as_xlsx = self.convert_to_xlsx(meta, data, columns, xlsx_data_types)
+            self.upload_xlsx(name, version, data_as_xlsx)
+            meta["files"].append({"filename": "data.xlsx", "format": "Excel"})
+
+        self.upload_csv(name, version, data_as_csv)
+        meta["files"].append({"filename": "data.csv", "format": "CSV"})
+
+        self.upload_tsv(name, version, data_as_tsv)
+        meta["files"].append({"filename": "data.tsv", "format": "TSV"})
+
+        if json:
+            self.upload_json(name, version, data)
+            meta["files"].append({"filename": "data.json", "format": "JSON"})
+
+        if jsonl:
+            self.upload_jsonl(name, version, data)
+            meta["files"].append({"filename": "data.jsonl", "format": "JSON Lines"})
+
+        if geojson and data_as_geojson_points:
+            self.upload_geojson_points(name, version, data_as_geojson_points)
+            meta["files"].append(
+                {"filename": "data.points.geojson", "format": "GeoJSON (Points)"}
+            )
+
+        if shapefile_blob:
+            self.upload_shapefile_points(name, version, shapefile_blob)
+            meta["files"].append(
+                {"filename": "data.points.shp.zip", "format": "Shapefile (Points)"}
+            )
+
+        if parquet and data_as_parquet_blob:
+            self.upload_parquet(name, version, data_as_parquet_blob)
+            meta["files"].append({"filename": "data.parquet", "format": "Parquet"})
+
+        self.upload_metadata(name, version, meta)

datablob-0.8.0.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: datablob
+Version: 0.8.0
+Summary: Client for Updating a Simple Data Warehouse on Blob Storage
+Home-page: https://github.com/gocarta/datablob
+Download-URL: https://github.com/gocarta/datablob/tarball/download
+Author: Daniel J. Dufour
+Author-email: daniel.j.dufour@gmail.com
+Keywords: data,python
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: boto3
+Requires-Dist: geopandas
+Requires-Dist: openpyxl
+Requires-Dist: pandas
+Requires-Dist: pyarrow
+Requires-Dist: shapely
+Requires-Dist: tzdata
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+# datablob
+Client for Updating a Simple Data Warehouse on Blob Storage
+
+## design philosophy
+- optimize for simplicity and user friendliness
+- storage is cheap (compared to compute)
+- pre-compute as much as possible
+- should work out of the box
+- advanced configuration should be opt-in
+- explicit is better than implicit
+- straightforwardness over magic
+
+## install
+```sh
+pip install datablob
+```
+
+## supported formats
+- csv
+- [geojson (points only)](https://geojson.org/)
+- json
+- [json lines](https://jsonlines.org/)
+- [parquet](https://parquet.apache.org/), including [geoparquet](https://geoparquet.org/)
+- [shapefile (points only)](https://en.wikipedia.org/wiki/Shapefile)
+- tsv
+- xlsx (Microsoft Excel)
+
+## basic usage
+```py
+from datablob import DataBlobClient
+
+client = DataBlobClient(
+    bucket_name="example-test-bucket-123", bucket_path="prefix/to/dataportal"
+)
+
+client.update_dataset(name="fleet", version="2", data=rows, xlsx=True)
+# automatically creates the following files
+# s3://example-test-bucket-123/prefix/to/dataportal/fleet/v2/meta.json
+# s3://example-test-bucket-123/prefix/to/dataportal/fleet/v2/data.csv
+# s3://example-test-bucket-123/prefix/to/dataportal/fleet/v2/data.points.geojson
+# s3://example-test-bucket-123/prefix/to/dataportal/fleet/v2/data.json
+# s3://example-test-bucket-123/prefix/to/dataportal/fleet/v2/data.jsonl
+# s3://example-test-bucket-123/prefix/to/dataportal/fleet/v2/data.parquet
+# s3://example-test-bucket-123/prefix/to/dataportal/fleet/v2/data.points.shp.zip
+# s3://example-test-bucket-123/prefix/to/dataportal/fleet/v2/data.tsv
+# s3://example-test-bucket-123/prefix/to/dataportal/fleet/v2/data.xlsx
+```
+
+## advanced usage
+```py
+client.update_dataset(
+    name="fleet",
+    version="1",
+    data=rows,
+    column_names=["ID", "Make", "Model", "Year"]
+    description="List of Vehicles in Fleet",
+    xlsx=True,
+    xlsx_data_types=["Number", "Text", "Text", "Number"]
+)
+```
+
+## examples
+- [Clever Vehicle Locations](https://github.com/gocarta/dataops-clever-vehicle-locations)
+- [Simple Bus Routes](https://github.com/gocarta/dataops-simple-bus-routes)
+- [Simple Bus Stops](https://github.com/gocarta/dataops-simple-bus-stops)

datablob-0.8.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+datablob/__init__.py,sha256=1tTI4098zU3BGn7Nh5ssgqnr_aIHiuU_-exGIXWeC3c,15853
+datablob-0.8.0.dist-info/licenses/LICENSE,sha256=9Ofzc7m5lpUDN-jUGkopOcLZC3cl6brz1QhKInF60yg,7169
+datablob-0.8.0.dist-info/METADATA,sha256=EMehVuRiyLLpjYohrJFCJKqjsIV0XXsykc-dEyiW8nQ,3270
+datablob-0.8.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+datablob-0.8.0.dist-info/top_level.txt,sha256=trYKBOas9qK0gyjeAqOB4i8C0UNYvELioROXl7NfdWU,9
+datablob-0.8.0.dist-info/RECORD,,

datablob-0.8.0.dist-info/WHEEL

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

datablob-0.8.0.dist-info/licenses/LICENSE

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

datablob-0.8.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+datablob