sdata 1.5.0__py3-none-any.whl

sdata/vocab.py

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+"""Vokabular & JSON-LD-``@context`` für die semantische Metadaten-Schicht.
+
+Reine-Python-Tabellen (keine Abhängigkeit): Namespace-Präfixe, ein
+``@context``-Builder, das XSD-Typ-Mapping (aus :mod:`sdata.dtypes`) und die
+Auflösung von BFO-Topologieklassen sowie von Attribut-``ontology``-Annotationen.
+
+Designentscheidungen (siehe Projektplan):
+
+* **Identität**: ``@id`` eines Objekts ist seine DID ``did:suuid:<sname>:sdata``.
+* **``ontology`` = immer ``@type``/Klasse** des Werts (z.B. ``bfo:Quality``); das
+  Subjekt→Wert-**Prädikat** kommt NICHT aus ``ontology``, sondern ist
+  ``sdata:<name>`` (bzw. ein gemappter schema.org/qudt-Term).
+"""
+import re
+
+import sdata.dtypes as dtypes
+
+__all__ = [
+    "SDATA_NS", "NAMESPACES", "CONTEXT_TERMS", "CONTEXT_URL", "BFO_IRIS",
+    "build_context", "xsd_for_dtype", "expand_curie", "bfo_iri",
+    "safe_term", "predicate_for", "type_iri",
+]
+
+#: Namespace-IRI des sdata-Vokabulars (auflösbar via GitHub Pages des Repos).
+SDATA_NS = "https://lepy.github.io/sdata/ns#"
+#: gehostetes JSON-LD-@context (statische Datei ``ns/context.jsonld`` im Repo-Root,
+#: von GitHub Pages unter dieser URL ausgeliefert).
+CONTEXT_URL = "https://lepy.github.io/sdata/ns/context.jsonld"
+
+NAMESPACES = {
+    "sdata":   SDATA_NS,
+    "schema":  "https://schema.org/",
+    "dcterms": "http://purl.org/dc/terms/",
+    "dcat":    "http://www.w3.org/ns/dcat#",
+    "prov":    "http://www.w3.org/ns/prov#",
+    "qudt":    "http://qudt.org/schema/qudt/",
+    "unit":    "http://qudt.org/vocab/unit/",
+    "xsd":     "http://www.w3.org/2001/XMLSchema#",
+    "bfo":     "http://purl.obolibrary.org/obo/",
+    "rdfs":    "http://www.w3.org/2000/01/rdf-schema#",
+    "csvw":    "http://www.w3.org/ns/csvw#",
+    "did":     "https://www.w3.org/ns/did#",
+}
+
+#: JSON-LD-Term-Definitionen (ergänzen die Präfixe im ``@context``).
+CONTEXT_TERMS = {
+    "name":            "schema:name",
+    "description":     "schema:description",
+    "generatedAtTime": {"@id": "prov:generatedAtTime", "@type": "xsd:dateTime"},
+    "wasDerivedFrom":  {"@id": "prov:wasDerivedFrom", "@type": "@id"},
+    "isPartOf":        {"@id": "dcterms:isPartOf", "@type": "@id"},
+    "identifier":      "dcterms:identifier",
+    "topologyClass":   {"@id": "sdata:topologyClass", "@type": "@id"},
+    "value":           "qudt:value",
+    "unitRef":         {"@id": "qudt:unit", "@type": "@id"},
+    "symbol":          "qudt:symbol",
+    "label":           "rdfs:label",
+    # Formelzeichen der Größe (RFC 0016); "symbol" bleibt das Einheiten-Symbol
+    "quantitySymbol":  "sdata:quantitySymbol",
+    "required":        {"@id": "sdata:required", "@type": "xsd:boolean"},
+    # tabellarische Spalten (CSVW)
+    "columns":         {"@id": "csvw:column", "@container": "@list"},
+    "datatype":        {"@id": "csvw:datatype", "@type": "@id"},
+    # Klasse der Spaltenwerte (``ontology`` der Spalte; wie ``rdfType`` im Data Package)
+    "rdfType":         {"@id": "sdata:rdfType", "@type": "@id"},
+}
+
+#: BFO-2.0-Klassenname -> OBO-CURIE (für ``_sdata_topology_class``).
+BFO_IRIS = {
+    "Entity": "bfo:BFO_0000001",
+    "Continuant": "bfo:BFO_0000002",
+    "Occurrent": "bfo:BFO_0000003",
+    "IndependentContinuant": "bfo:BFO_0000004",
+    "SpatialRegion": "bfo:BFO_0000006",
+    "Process": "bfo:BFO_0000015",
+    "Disposition": "bfo:BFO_0000016",
+    "RealizableEntity": "bfo:BFO_0000017",
+    "Quality": "bfo:BFO_0000019",
+    "SpecificallyDependentContinuant": "bfo:BFO_0000020",
+    "Role": "bfo:BFO_0000023",
+    "Site": "bfo:BFO_0000029",
+    "GenericallyDependentContinuant": "bfo:BFO_0000031",
+    "Function": "bfo:BFO_0000034",
+    "MaterialEntity": "bfo:BFO_0000040",
+    "ImmaterialEntity": "bfo:BFO_0000141",
+    "RelationalQuality": "bfo:BFO_0000145",
+}
+
+
+def build_context(mode="inline", extra=None):
+    """Liefere das JSON-LD-``@context`` (``inline`` = vollständige Term-Map) oder
+    – bei ``mode="url"`` – die gehostete Context-URL.
+
+    :param mode: ``"inline"`` (default) oder ``"url"``
+    :param extra: optionale zusätzliche Term-Definitionen
+    """
+    if mode == "url":
+        return CONTEXT_URL
+    ctx = dict(NAMESPACES)
+    ctx.update(CONTEXT_TERMS)
+    if extra:
+        ctx.update(extra)
+    return ctx
+
+
+def xsd_for_dtype(dtype):
+    """XSD-Typ-CURIE für einen sdata-dtype (String oder Klasse)."""
+    return dtypes.XSD.get(dtypes.resolve(dtype) or "str", "xsd:string")
+
+
+def expand_curie(curie):
+    """Expandiere eine CURIE (``schema:name``) zur vollen IRI; IRIs/Unbekanntes
+    werden unverändert zurückgegeben."""
+    if not isinstance(curie, str) or ":" not in curie:
+        return curie
+    prefix, _, local = curie.partition(":")
+    if curie.startswith("http://") or curie.startswith("https://"):
+        return curie
+    base = NAMESPACES.get(prefix)
+    return base + local if base else curie
+
+
+def bfo_iri(topology_class):
+    """Mappe einen Topologieklassen-String (``"sdata.sclass:IndependentContinuant"``)
+    auf die BFO-CURIE oder ``None``, falls unbekannt/leer."""
+    if not topology_class:
+        return None
+    local = str(topology_class).rsplit(":", 1)[-1]
+    return BFO_IRIS.get(local)
+
+
+def safe_term(name):
+    """Normalisiere einen Attributnamen zu einem CURIE-tauglichen lokalen Teil."""
+    local = re.sub(r"[^0-9A-Za-z_]", "_", str(name)).strip("_")
+    return local or "attribute"
+
+
+def predicate_for(attr_name):
+    """Subjekt→Wert-Prädikat für ein User-Attribut: Default ``sdata:<safe_name>``."""
+    return "sdata:" + safe_term(attr_name)
+
+
+def type_iri(ontology):
+    """``@type``/Klasse eines Werts aus dem ``ontology``-Feld (CURIE/IRI) oder
+    ``None``. (``ontology`` ist per Projektentscheidung stets eine Klasse.)"""
+    if not ontology:
+        return None
+    return str(ontology)

sdata-1.5.0.dist-info/METADATA

@@ -0,0 +1,264 @@
+Metadata-Version: 2.4
+Name: sdata
+Version: 1.5.0
+Summary: a structured data format
+Author-email: Ingolf Lepenies <lepy@tuta.io>
+Maintainer-email: Ingolf Lepenies <lepy@tuta.io>
+License: MIT
+Project-URL: Homepage, https://github.com/lepy/sdata
+Project-URL: Documentation, https://lepy.github.io/sdata/
+Keywords: open data
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE-MIT
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: suuid>=0.2.0
+Provides-Extra: did
+Provides-Extra: http
+Requires-Dist: requests; extra == "http"
+Provides-Extra: excel
+Requires-Dist: openpyxl; extra == "excel"
+Requires-Dist: xlsxwriter; extra == "excel"
+Requires-Dist: tabulate; extra == "excel"
+Provides-Extra: hdf
+Requires-Dist: h5py; extra == "hdf"
+Provides-Extra: sql
+Requires-Dist: sqlalchemy; extra == "sql"
+Provides-Extra: parquet
+Requires-Dist: pyarrow; extra == "parquet"
+Provides-Extra: blob
+Requires-Dist: fsspec; extra == "blob"
+Provides-Extra: units
+Requires-Dist: pint; extra == "units"
+Provides-Extra: rdf
+Requires-Dist: rdflib; extra == "rdf"
+Provides-Extra: schema
+Requires-Dist: jsonschema; extra == "schema"
+Dynamic: license-file
+
+
+[![PyPI](https://img.shields.io/pypi/v/sdata.svg?style=flat-square)](https://pypi.python.org/pypi/sdata/)
+[![Python versions](https://img.shields.io/pypi/pyversions/sdata.svg?style=flat-square)](https://pypi.python.org/pypi/sdata/)
+[![Docs](https://img.shields.io/badge/docs-mkdocs--material-blue?style=flat-square)](https://lepy.github.io/sdata/)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4311323.svg)](https://doi.org/10.5281/zenodo.4311323)
+
+# Structured data format (sdata)
+
+## Design goals & status
+
+sdata is an open, self-describing data format for open-science projects. The
+table below is an honest status of the original design goals (triaged in
+[RFC 0008](docs/rfc/0008-bestandsaufnahme-roadmap.md)) — **implemented**,
+**partial**, on the **roadmap**, or an explicit **non-goal**.
+
+| Goal | Status | Notes |
+|------|--------|-------|
+| Open, self-describing data | **implemented** | metadata embedded in every format |
+| Platform independent, simple object model | **implemented** | pure Python / numpy / pandas |
+| Standard metadata formats (key/value, JSON-LD, …) | **implemented** | `Metadata`, QUDT/BFO/PROV/CSVW/DID/VC |
+| Physical units + conversion | **implemented** | `sdata.units` (RFC 0006) |
+| Standard dataset formats — HDF5, CSV, Parquet, Arrow, Data Package | **implemented** | HDF5 via `sdata[hdf]` |
+| (De-)serialization of data + metadata | **implemented** | lossless round-trips |
+| Data format versions | **implemented** | `_sdata_format_version` + migration (RFC 0010) |
+| Project standards (e.g. tensile test) | **partial** | schema templates (`MetadataSchema`/`TableSchema`) |
+| Series | **partial** | as a one-column table |
+| Hierarchical structure / nested groups | **partial** | `DataFrameGroup` (flat) + `parent`/`project` relations |
+| Transparent compression | **partial** | Parquet-internal (zstd); zlib is a **non-goal** for the store (speed) |
+| Standard dataset formats — **netCDF** | **roadmap** | not implemented |
+| Dataset types — **datacubes** | **roadmap** | not implemented |
+| Optional encryption (gpg, …) | **non-goal** | encrypt blobs/filesystem out of band |
+| posix-path syntax, change management, tensor-library interop, SWMR | **non-goal** | not planned; revisit on demand |
+
+Machine-readable metadata is the backbone (see below); the optional semantic
+backends degrade gracefully to pure Python.
+
+## Quickstart
+
+```python
+import pandas as pd
+from sdata.sclass.dataframe import DataFrame
+
+df = pd.DataFrame({"force": [1.0, 2.0, 3.0]})
+data = DataFrame(df=df, name="specimen_01", description="a tension test")
+data.metadata.add("max_force", 12.5, unit="kN", dtype="float",
+                  description="max force", ontology="bfo:Quality")
+
+print(data.metadata.df[["value", "unit", "dtype", "ontology"]])
+```
+
+```
+                                          value unit  dtype     ontology
+key
+_sdata_name                         specimen_01    -    str
+_sdata_sname    DataFrame__specimen_01__3003...    -    str
+...
+max_force                                  12.5   kN  float  bfo:Quality
+```
+
+Every object has a deterministic, content-addressable identity (`SUUID`), a set
+of reserved `_sdata_*` attributes (name, sname, suuid, class, ctime, parent,
+project, topology class) and freely extensible, fully-described user attributes.
+
+## Machine-readable metadata (JSON-LD / Linked Data)
+
+The metadata is the backbone of the data description: it lives next to every
+data blob and fully qualifies the data — units (QUDT/UCUM), ontology classes
+(BFO), provenance (PROV/DCAT), tabular columns (CSVW) and identity (DID).
+
+```python
+# self-describing JSON-LD (qudt:Quantity units, BFO @type, did:suuid @id, csvw columns)
+doc = data.to_jsonld()
+
+# RDF/Turtle (uses rdflib if installed, otherwise returns the JSON-LD)
+print(data.to_turtle())
+
+# write the data + a sidecar <sname>.meta.jsonld right next to it
+data.to_json("specimen_01.sjson", sidecar=True)
+
+# validate / auto-complete against a schema template
+from sdata.schema import MetadataSchema, AttrSpec
+schema = MetadataSchema("TensileTest", [
+    AttrSpec("max_force", dtype="float", unit="kN", required=True, ontology="bfo:Quality"),
+])
+report = data.metadata.validate(schema)      # ValidationReport (truthy if ok)
+
+# sign the metadata as a W3C Verifiable Credential (pure-Python Ed25519)
+from sdata.did import keys, pub_from_priv_jwk
+priv = keys.gen_ed25519_jwk()
+vc = data.metadata.to_verifiable_credential("did:example:issuer", priv)
+subject = data.metadata.from_verifiable_credential(vc, pub_from_priv_jwk(priv))
+
+# interactive: attribute autocomplete + rich Jupyter display
+data.metadata.a.max_force        # -> Attribute; tab-completion in Jupyter
+data.metadata                    # -> _repr_html_ table
+```
+
+Resulting JSON-LD for `max_force` (excerpt):
+
+```json
+{
+  "@id": "did:suuid:DataFrame__specimen_01__3003...:sdata",
+  "@type": ["sdata:DataFrame", "bfo:BFO_0000004"],
+  "name": "specimen_01",
+  "sdata:max_force": {
+    "@type": ["qudt:Quantity", "bfo:Quality"],
+    "value": {"@value": 12.5, "@type": "xsd:double"},
+    "unitRef": "unit:KiloN", "symbol": "kN"
+  },
+  "columns": [{"name": "force", "datatype": "xsd:double"}]
+}
+```
+
+The optional semantic backends degrade gracefully to pure Python (no hard
+dependency): `pip install "sdata[rdf]"` (rdflib), `sdata[units]` (pint),
+`sdata[schema]` (jsonschema). Core install needs only `numpy`, `pandas`, `suuid`.
+
+## Tabular data (`DataFrame`)
+
+`DataFrame` wraps a pandas frame plus per-column metadata and serializes to many
+formats — Parquet, Arrow/Feather, CSV, dict/JSON, JSON-LD, a Frictionless **Data
+Package** and **HDF5** — with the qualifying metadata embedded or written as a
+sidecar.
+
+```python
+import pandas as pd
+from sdata.sclass.dataframe import DataFrame
+
+sdf = DataFrame(df=pd.DataFrame({"weight": [10, 20], "height": [1.5, 1.6]}),
+                name="specimen_01", description="a tension test")
+
+# per-column annotations (only the fields you pass are changed)
+sdf.set_column("weight", unit="kg", label="Gewicht", ontology="bfo:Quality")
+sdf.col["height"].unit = "m"          # mutate the column Attribute in place
+sdf.column_units                       # {'weight': 'kg', 'height': 'm'}
+
+# serialize (optional <sname>.meta.jsonld sidecar; bytes/str without a path)
+sdf.to_parquet(path="out", sidecar=True)      # out/<sname>.spq + sidecar
+sdf.to_csv(path="out")                         # data-only CSV (pure pandas)
+sdf.to_feather(path="out")                     # Arrow IPC + native per-column field metadata
+sdf.to_datapackage(path="out")                 # Frictionless Data Package (.zip)
+sdf.to_hdf(path="out")                         # HDF5 via h5py, one dataset/column (sdata[hdf])
+DataFrame.from_parquet("out/specimen_01.spq")
+
+# validate the table against a schema (missing/dtype/unit/extra columns)
+from sdata.schema import TableSchema, AttrSpec
+schema = TableSchema("TensileTable", [
+    AttrSpec("weight", dtype="int", unit="kg", required=True),
+])
+report = sdf.validate_table(schema)            # ValidationReport (truthy if ok)
+```
+
+Arrow/Feather/Parquet need `pip install "sdata[parquet]"`, HDF5 `sdata[hdf]`; CSV,
+dict, JSON-LD and the (CSV) Data Package work with the core install. See the
+[Tabular data docs](https://lepy.github.io/sdata/usage/dataframe/)
+([`docs/usage/dataframe.md`](docs/usage/dataframe.md)) for the full reference.
+
+## Howto
+
+  
+* [Das sdata-Format - slides](https://lepy.github.io/sdata/ipynb/Das_sdata_Format.slides.html#)
+* https://deepwiki.com/lepy/sdata
+
+## Demo App
+
+* [test the demo app with editor](https://share.streamlit.io/lepy/sdata_streamlit/main/sdata_editor.py)
+
+Try to paste some Excel-Data in the forms ...
+
+
+## Metadata
+
+### Attributes
+
+* name
+* value
+* dtype
+* unit
+* description
+* label
+* required
+* ontology (CURIE/IRI of the value's class, e.g. `bfo:Quality`)
+
+### dtypes for attributes
+
+Every attribute value is coerced to a declared dtype (single source:
+`sdata.dtypes`), each with a lossless JSON-LD / XSD mapping:
+
+* `int`, `float`, `str`, `bool`
+* `list` (list of strings), `floatlist` (typed list of floats)
+* `timestamp` (ISO-8601 with timezone, stdlib `zoneinfo`)
+* `date`, `time`, `duration` (ISO-8601 / `datetime` types)
+* `decimal` (exact decimal), `complex` (complex number)
+* `bytes` (base64 in JSON), `json` (dict/list), `uri`
+* `langstring` (language-tagged string, `rdf:langString`, e.g. `"Hallo@de"`)
+
+Coercion is **lenient** by default (invalid values are logged and left unchanged).
+Pass `strict=True` (e.g. `metadata.add(..., strict=True)`) to raise `DtypeError`
+instead. See the [conventions](https://lepy.github.io/sdata/conventions/) for the
+error policy.
+
+## paper
+
+* [Das sdata-Format](https://zenodo.org/record/4311323#.X89yo9-YXys)
+    * Ingolf Lepenies. (2020). Das sdata-Format (Version 0.8.4). http://doi.org/10.5281/zenodo.4311323 
+    * [slides](https://lepy.github.io/sdata/ipynb/Das_sdata_Format.slides.html#),
+    [html](https://lepy.github.io/sdata/paper/2020/Das_sdata-Format.html), 
+    [pdf](https://lepy.github.io/sdata/paper/2020/Das_sdata-Format.pdf)
+    [temperaturmessung-001.json](https://lepy.github.io/sdata/paper/2020/temperaturmessung-001.json)
+    [temperaturmessung-001.xlsx](https://lepy.github.io/sdata/paper/2020/temperaturmessung-001.xlsx)
+    
+* [sdata](https://doi.org/10.5281/zenodo.4311396)
+    * Ingolf Lepenies. (2020, December 8). sdata - a structured data format (Version 0.8.4). Zenodo. http://doi.org/10.5281/zenodo.4311397
+

sdata-1.5.0.dist-info/RECORD

@@ -0,0 +1,98 @@
+sdata/__init__.py,sha256=-dI783pOCXydCJVS71HU9EDfZExf1jWK38qahVm7Erg,4716
+sdata/base.py,sha256=5R6CWnuthahksvR6biLKrFq2YzfggbCCtn80wv5J4es,24399
+sdata/doe.py,sha256=0F87fwsl8OqDkAXd907-MamiK85WhH8B0XgaSBHmMZw,3131
+sdata/dtypes.py,sha256=dvg0XsbZ4dB0iwzNSeq5tahGc29zLT2XDYI_p35DnaY,17952
+sdata/format.py,sha256=oyWvesvSVqMoYub8p0SUUd-3pfzj0H4TNbUMEpB7v1M,4779
+sdata/imagemeta.py,sha256=Qd7sylMjM6KZyaRkt3_NGCTFIuRXf9b-bwm5vOfUvMY,20874
+sdata/interactive.py,sha256=e5QqE2MkVZE7X-9d20NiT2yjfD672HU2pCi5J3w2kDI,4273
+sdata/metadata.py,sha256=dRN6-8ZLDqLMKnx6AADjKrCQVSxMQMAHMhZaHOpzZa4,29467
+sdata/parameter.py,sha256=XdF9Nmi4WwMkwmTFGGn7jhc12kHPkiac_GSQf6vyd_0,13652
+sdata/schema.py,sha256=M1CSm6C2X3Rvw8LlNCRuY8z-L61uZwhSc2UQOTs8RAU,10933
+sdata/semantic.py,sha256=aC7seRkomXD__np-m_YItVQ3WmbvB7bdAErYDIE78Do,12706
+sdata/suuid.py,sha256=TJftRPguUgyu4XTSXiaIgW4F3Dj33nmjcTNhh90baVY,5549
+sdata/timestamp.py,sha256=6tP_Phl9fwbjxIVdFJ2QhYqux6Zw76n1x6azRZ14Pv0,10279
+sdata/tools.py,sha256=dhvllyLdk27qQ789iCVt0-n61tJ4RxRG29w5FXEoPqk,337
+sdata/units.py,sha256=7NGg_wsa_qCEORMPr371R7vBrWYBLa33vPWQewUZde4,24925
+sdata/vocab.py,sha256=9KcnKVMRfPK5USuVw2F2ABrnztwiT2Ic4Q95tIaS9dw,5780
+sdata/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sdata/contrib/sobol_seq.py,sha256=MRId2aaG66UOjYcs6Yt4EV1Xndu1t4ASJpTf_I38hhI,12870
+sdata/contrib/sqlitedict.py,sha256=FA1hLZfOyWcjdjQgunyFk0pvxN8-JACol7COFdD_Rwg,22903
+sdata/contrib/piexif/__init__.py,sha256=rezSWjJWI9hsUDIt49f04x8ziNeZianluuD2Cq64uDk,231
+sdata/contrib/piexif/_common.py,sha256=PNDCYnbeJNA8Zae-YDtFdzqLFOQ35v9Mv2GaAr9w9Bc,2590
+sdata/contrib/piexif/_dump.py,sha256=zozYuWiRPYKObyZmoaa4eXZYfuK7yU0LHziW2pXDG2c,12749
+sdata/contrib/piexif/_exceptions.py,sha256=17AbJRsaB0m519TAOmT2pgOzp75quibOCk0WBoDO06s,50
+sdata/contrib/piexif/_exif.py,sha256=N9NjeoYNSlBV37RbVLHOwX_OGiJq14RUpJI3kcvLKIQ,29812
+sdata/contrib/piexif/_insert.py,sha256=2tSkjFjJDwGNRycBptvQeS8Rl0Z5DrdgkGEeR7lXs2E,1868
+sdata/contrib/piexif/_load.py,sha256=jKIrEWD1yjhF47gsAvRDyTCKbiVf5JkSjxuLNqwuXyU,12230
+sdata/contrib/piexif/_remove.py,sha256=s7JtaEdpNl_1S9gZKVvNg4ItHE4sEhm4lFooYliP_wc,1535
+sdata/contrib/piexif/_transplant.py,sha256=Z4KytfkdYqhIpVCBg4rIPClfZP35HKhwYym3uSphn7Q,1225
+sdata/contrib/piexif/_webp.py,sha256=gAq26vEdS2LaKgsR2219lSsDQzH4mqikemI0zuNkAao,7889
+sdata/contrib/piexif/helper.py,sha256=dAil29ji-kEPb3y7QPtUEOUOqBoah9B2rSmltepBksI,2460
+sdata/contrib/ranger/__init__.py,sha256=7HB21tTtNqzCRCe_diignOfOJXRFBijTbQwcGXhkHJY,323
+sdata/contrib/ranger/collections/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sdata/contrib/ranger/collections/rangebucketmap.py,sha256=su_qeRz-g025JtxPe6IPBEHJbF-VDR3e9guk2xB0jhw,16305
+sdata/contrib/ranger/collections/rangemap.py,sha256=C2TaT4Tt4Z3jaPKxDDRatbt8UyGP_fC4wps3d1U8zzs,16239
+sdata/contrib/ranger/collections/rangeset.py,sha256=3FG8ylCQt6ezcOoDrm_qxFzoDRgYy-kz4aUQWAqJuO8,20556
+sdata/contrib/ranger/range/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sdata/contrib/ranger/range/cut.py,sha256=DE_SlzlFcmr8WSUcM1AwgPx3hwdSCBKhhvv-syI3qXA,8833
+sdata/contrib/ranger/range/range.py,sha256=_sRyZCEF7KdjMDZ3tuYAye30YC6uzzQgBuGR_ljx9JY,19804
+sdata/contrib/sortedcontainers/LICENSE,sha256=HbfK5_zmRS4uYI5AGg-VPgEz5MLXXbafuK6FHSCG9bY,557
+sdata/contrib/sortedcontainers/__init__.py,sha256=KNPfSbw7lLIaInY6zANDaD9c-pTfxQ0HaEpIfk46qOQ,2131
+sdata/contrib/sortedcontainers/sorteddict.py,sha256=yGLHZOwcSqYe3Ed2iZcMpQH5RH_ypG_rbexj-45_nL0,22154
+sdata/contrib/sortedcontainers/sortedlist.py,sha256=rwA1dM8ce09eb2DMjLOfHoikhCx_Rfk5nuE_NSsfr3I,76331
+sdata/contrib/sortedcontainers/sortedset.py,sha256=5RI2CUJGMm1ig3-dhbOrzDl8aPqDePkoJPQoq0ROS7M,19825
+sdata/contrib/timeflake/__init__.py,sha256=cWKQH48zZwXNW2x-UqljzLJxgu7JvPrEg8o1NGU_qiI,1283
+sdata/contrib/timeflake/flake.py,sha256=OSNCEVo3Vo57PBOzkJa9iHKajU_walmEicyUptPFKCo,1735
+sdata/contrib/timeflake/utils.py,sha256=AdyaF91dLt8mJDwANz2m3a0GSebhggCxgmA2SdN2IA0,1044
+sdata/deprecated/__init__.py,sha256=ask8WL4L0Zf4U6iseEwb9k_ffhl9fi5dqBgRJ4bqjbY,336
+sdata/deprecated/data.py,sha256=dI3Ae9Y01dqfmyepUTxHJc9pedjHzjR5nrZNACoNCz8,50953
+sdata/did/__init__.py,sha256=zjWI5D3HFLft1btrzWSE3PIBvpwH9vHxfyLKQ4CHrEY,6217
+sdata/did/_http.py,sha256=cHObbRCJsAeratlpIF8Ctz2Z3itGTyxBehS8LMgZ_sE,2510
+sdata/did/base58btc.py,sha256=0KcHYQI9Kotp9qaEhdiyw3WycuKqN284mlR0tHpfqnY,1566
+sdata/did/did_github.py,sha256=JG-ktgZQRVl9L8vy38ndRhnrqxDTV7jWvmUOJy1YTJQ,5155
+sdata/did/did_peer4.py,sha256=9CZxQl-zX2JVt45eg4qCTtyKe2X4kCc4mPvltHNBTu8,5721
+sdata/did/did_web.py,sha256=Z-MkbU4uuzff42ABMQG0e4Gi1HrL_rXQBHcRuytXsro,8190
+sdata/did/diddoc.py,sha256=8yFWKe3sBxRZKti4663R8z1lpoB88DRQPjyavJxnTk8,2451
+sdata/did/ed25519.py,sha256=j9gfF8qViEGq01UoBp9vqNTGB0ugShHUp-hVrOgCM6M,6924
+sdata/did/eddsa.py,sha256=MfAmhU-LT_5LWqpq3tgUa8TtAKWvjwxFVru3zGy8Lr0,3638
+sdata/did/errors.py,sha256=RHx7MRqq0KgBX34JBhfbGv4saRMsI5inQQj_D3C00zI,1388
+sdata/did/issue_vc.py,sha256=HS3KV0ydOWDRY4H4-xIZfbyDh75fMPQLQhwDssWsoUo,6781
+sdata/did/jose.py,sha256=KRk8-0MCsx37di2hg0B1nU24D2Q4vt9Zq9BBt0pFad8,4903
+sdata/did/keys.py,sha256=zm6BFFte4EIECg6Z9scLbfmbz5JjcdnsHtcDNv6YV6Q,3520
+sdata/did/utils_didkey.py,sha256=wJm_5QjHeT6muNlAgSM17P-_DWMaXBBxA8ujGE7_fq4,6318
+sdata/did/verify_vp.py,sha256=8ihY4urrajjPVJvlQ3vHgvc39OO0tWrEf5VvHpVKxOM,5667
+sdata/experiments/__init__.py,sha256=enImO0mzemJwTzz9tgkJ0jLtys3Lkr9RAKa4Eshph14,13342
+sdata/experiments/blob0.py,sha256=2aeHR-4o7x_W4cPz6-B9H9ynRsy9mVB1QY9fOb1HBeE,3639
+sdata/experiments/file.py,sha256=rdeP3AF5-9eKtLebA3e0bESloo6_Hlc0nHAVWnbD_18,856
+sdata/experiments/filegroup.py,sha256=QcXks1u6gNmja6dZq3Q-pa3aI1k0cYxeF-DuJVoqqAM,5109
+sdata/experiments/image_old.py,sha256=xz3tyH_WCnbmYZXq1diwBnYEN3aJoSEhEiYdK4HSaRQ,9597
+sdata/experiments/ks2.py,sha256=AsVJNfrsiICefYfYdBHB3GfnoW7gy1CyAy-kZsgfVSQ,834
+sdata/experiments/lapshear.py,sha256=iBdKQve7_UMKUDcsMs4HSr4J1OA3tWGnVZ43Oz-MzYA,281
+sdata/experiments/material.py,sha256=qV2-mGqPT_LKCk2lcnVUC1Yhqy_O0dhRd8sSZLNMdeU,318
+sdata/experiments/parameters_deprecated.py,sha256=TNAGGxLyZp1bf8SFjUZd3V986x036j8Sib3dzXGf3I4,13631
+sdata/experiments/workbook.py,sha256=aWM9_Y9jeCdApEoMcE1t5vGN4iT41zKCxTOkWjaQFxo,6933
+sdata/iolib/__init__.py,sha256=x_V0Vqx2yZeFOWyM1fWT4B_Wyb6a8wmP4IYw3WikpX4,1383
+sdata/iolib/hashtree.py,sha256=nF7OJiIGofggOmc7WUVU4lhLmX07xqzhI6z7N26qWmo,8989
+sdata/iolib/json1sqlitestore.py,sha256=yLVbPDvFa849EhXyC3AmwxwMUsconUw11J58UNDWgBg,23360
+sdata/iolib/jsonsqlitestore.py,sha256=iQ1rCC6sNujHO2OJ5C-SpZlJ3enj7pXVd7xc0ezgev0,22600
+sdata/iolib/pud.py,sha256=EKPmkKbOq2ukTq1S0Lh5VW53oxRSCumCA9fGhpGYMGc,9565
+sdata/iolib/reader.py,sha256=u_1HrjOKJv2ckV-8SBRHfjEa2pq8l9xfnRueZQ7UlhE,10759
+sdata/iolib/writer.py,sha256=NHBU6dweQZrkf46gqH_rtVwurhcHgqu8dN2Twjidmto,17369
+sdata/sclass/__init__.py,sha256=A3cwPakW0wCTGUZYA6cu5kE60XXEIJXcsqxKM_M2aO8,3716
+sdata/sclass/bfo_classes.py,sha256=bggtMF05598KA5vomlNkSxHL433Cpe87CUZUOEu0NAc,16775
+sdata/sclass/blob.py,sha256=eQSSPWcGGNoII2XpU_Fv0WKIwVZLRCweUaSSOBScCKk,15082
+sdata/sclass/content.py,sha256=ShMbTTfzApUG5nkvATsEaJNXIS0cG6jbflkyfuJ95QE,3290
+sdata/sclass/dataframe.py,sha256=U3VAlBswqXvq9jz2R3lZdR4ZBLTFx2l8buhlKLKclHk,57525
+sdata/sclass/dataframegroup.py,sha256=Tc5_E-CGINlWXgZqWUFQ7Z53_VpgCjT7KFjnYFp3IYM,8728
+sdata/sclass/dependency_graph.py,sha256=_nPq_65WkDoazG2cLoF3IivRCfZivtShJ9e-Ws9lxnE,3097
+sdata/sclass/filereference.py,sha256=Gh5k6cYNSS3qcCG8-iyOk1Go1FcKNdGElgEFwrMfLBs,4485
+sdata/sclass/image.py,sha256=J3h4LLHswAoQa2cI6jUjaKHnS17Jl1rNJ_tV5MkDNyc,9453
+sdata/sclass/lazy_namespace.py,sha256=s-u1jJW7gVkd2SlSNTLD7xVbIMOcAmXfXWclY6Rjl6Y,6193
+sdata/sclass/process.py,sha256=baelESWEeuRGHy2bAWOumIRhmxkRp1IxYQYJqN2eYJA,14801
+sdata/sclass/process_graph.py,sha256=d4lIyLesJK83bgQ--JbatxjB0IVz3PJG0-5LK1ATnIs,8532
+sdata/sclass/zipfile.py,sha256=Rbmnbc7bPmTex7VedUunqsAsfY81ixuJZQ-LIJxgeAk,5064
+sdata-1.5.0.dist-info/licenses/LICENSE-MIT,sha256=5U6rYVFnGH6sgX_ZHqovb03c5sjFG0SxcUhCeBIz74s,1066
+sdata-1.5.0.dist-info/METADATA,sha256=3dZt-z0Mk2Z7hnPpc__kQv59N5LB8nTwB83jtYW5KCQ,11204
+sdata-1.5.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+sdata-1.5.0.dist-info/top_level.txt,sha256=5HOjejfoO5ta_hkVFnEhX0T0L7YrtdcfhUu9FesNWfk,6
+sdata-1.5.0.dist-info/RECORD,,

sdata-1.5.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
+

sdata-1.5.0.dist-info/licenses/LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-2020 lepy
+
+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.

sdata-1.5.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sdata