sdata 0.19.0__tar.gz → 0.22.0__tar.gz

sdata-0.22.0/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.1
+Name: sdata
+Version: 0.22.0
+Summary: a structured data format
+Home-page: https://github.com/lepy/sdata
+Author: Lepy
+Author-email: lepy@mailbox.org
+Maintainer: Lepy
+Maintainer-email: lepy@mailbox.org
+License: MIT/Apache-2.0
+Keywords: open data
+Platform: UNKNOWN
+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 :: 2.7
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Description-Content-Type: text/markdown
+License-File: LICENSE-MIT
+
+
+[![PyPI version](https://badge.fury.io/py/sdata.svg)](https://badge.fury.io/py/sdata)
+[![PyPI](https://img.shields.io/pypi/v/sdata.svg?style=flat-square)](https://pypi.python.org/pypi/sdata/)
+[![readthedocs](https://readthedocs.org/projects/sdata/badge/?version=latest)](http://sdata.readthedocs.io/en/latest/) 
+[![Build Status](https://travis-ci.org/lepy/sdata.svg?branch=master)](https://travis-ci.org/lepy/sdata)
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/107e46dc4eee4b58a6ef82fce3043a3e)](https://www.codacy.com/app/lepy/sdata?utm_source=github.com&utm_medium=referral&utm_content=lepy/sdata&utm_campaign=Badge_Grade)
+[![Coverage Status](https://coveralls.io/repos/github/lepy/sdata/badge.svg?branch=master)](https://coveralls.io/github/lepy/sdata?branch=master)
+[![Das sdata-Format v0.8.4](https://zenodo.org/badge/DOI/10.5281/zenodo.4311323.svg)](https://doi.org/10.5281/zenodo.4311323)
+
+https://lepy.github.io/sdata/
+
+# Structured data format (sdata)
+
+## Design goals
+
+* open data format for open science projects
+* self describing data
+* flexible data structure layout
+    * hierarchical data structure (nesting groups, dictionaries)
+    * (posix path syntax support?)
+* extendable data structure
+   * data format versions
+* platform independent
+* simple object model
+* support of standard metadata formats (key/value, ...)
+* support of standard dataset formats (hdf5, netcdf, csv, ...)
+* support of standard dataset types (datacubes, tables, series, ...)
+* support of physical units (conversion of units)
+* transparent, optional data compression (zlib, blosc, ...)
+* support of (de-)serialization of every dataset type (group, data, metadata)
+* easy defineable (project) standards, e.g. for a uniaxial tension test (UT)
+* (optional data encryption (gpg, ...))
+* change management support?
+* Enable use of data structures from existing tensor libraries transparently
+* (single writer/ multiple reader (swmr) support)
+* (nested data support)
+
+```
+df = pandas.DataFrame({"a":[1,2,3]})
+import sdata
+data = sdata.Data(name="my_data", table=df, comment="A remarkable comment")
+data.metadata.add("my_key", 123, unit="m^3", description="a volume")
+data.metadata.add("force", 1.234, unit="kN", description="x force")
+data.to_xlsx(filepath="my_data.xlsx")
+print(data.metadata.df)
+```
+
+```
+          name                             value  dtype unit description
+key                                                                     
+name      name                           my_data    str    -            
+uuid      uuid  08222ca66e5047808bdc3b35d8f17224    str    -            
+my_key  my_key                               123    int  m^3    a volume
+force    force                             1.234  float   kN     x force
+```
+## Howto
+
+  
+* [Das sdata-Format - slides](https://lepy.github.io/sdata/ipynb/Das_sdata_Format.slides.html#)
+
+
+## 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
+
+### dtypes for attributes
+
+* int
+* float
+* str
+* bool
+* timestamp (datetime.isoformat with timezone)
+
+## 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-0.19.0 → sdata-0.22.0}/sdata/__init__.py

@@ -1,7 +1,7 @@
 # -*-coding: utf-8-*-
 from __future__ import division
 
-__version__ = '0.19.0'
+__version__ = '0.22.0'
 __revision__ = None
 __version_info__ = tuple([int(num) for num in __version__.split('.')])
 
@@ -21,6 +21,7 @@ import pandas
 from sdata.metadata import Metadata, Attribute
 from sdata.data import Data
 from sdata.blob import Blob
+from sdata.suuid import SUUID
 
 # import sdata.timestamp as timestamp
 from sdata.timestamp import today_str, now_utc_str, now_local_str
@@ -36,6 +37,7 @@ except:
 def uuid_from_str(name):
     return uuid.uuid3(uuid.NAMESPACE_DNS, name)
 
+
 def osname(name, lower=True):
     mapper = [("ä", "ae"), ("ö", "oe"), ("ü", "ue"), ("Ä", "Ae"), ("Ö", "Oe"), ("Ü", "Ue"),
               ("ß", "sz"), (" ", "_"), ("/", "_"), ("\\", "_")]
@@ -45,11 +47,13 @@ def osname(name, lower=True):
         name = name.lower()
     return name.encode('ascii', 'replace').decode("ascii")
 
+
 SDATACLS = {"Data": Data,
             "Blob": Blob,
+            "SUUID": SUUID,
             }
 
-__all__ = ["Data", "Blob"]
+__all__ = ["Data", "Blob", "SUUID"]
 
 
 def print_classes():

sdata-0.22.0/sdata/contrib/attrdict/__init__.py

@@ -0,0 +1,10 @@
+"""
+attrdict contains several mapping objects that allow access to their
+keys as attributes.
+"""
+from .mapping import AttrMap
+from .dictionary import AttrDict
+from .default import AttrDefault
+
+
+__all__ = ['AttrMap', 'AttrDict', 'AttrDefault']

sdata-0.22.0/sdata/contrib/attrdict/default.py

@@ -0,0 +1,133 @@
+"""
+A subclass of MutableAttr that has defaultdict support.
+"""
+try:
+    from collections.abc import Mapping
+except ImportError:
+    from collections import Mapping
+
+import six
+
+from .mixins import MutableAttr
+
+
+__all__ = ['AttrDefault']
+
+
+class AttrDefault(MutableAttr):
+    """
+    An implementation of MutableAttr with defaultdict support
+    """
+    def __init__(self, default_factory=None, items=None, sequence_type=tuple,
+                 pass_key=False):
+        if items is None:
+            items = {}
+        elif not isinstance(items, Mapping):
+            items = dict(items)
+
+        self._setattr('_default_factory', default_factory)
+        self._setattr('_mapping', items)
+        self._setattr('_sequence_type', sequence_type)
+        self._setattr('_pass_key', pass_key)
+        self._setattr('_allow_invalid_attributes', False)
+
+    def _configuration(self):
+        """
+        The configuration for a AttrDefault instance
+        """
+        return self._sequence_type, self._default_factory, self._pass_key
+
+    def __getitem__(self, key):
+        """
+        Access a value associated with a key.
+
+        Note: values returned will not be wrapped, even if recursive
+        is True.
+        """
+        if key in self._mapping:
+            return self._mapping[key]
+        elif self._default_factory is not None:
+            return self.__missing__(key)
+
+        raise KeyError(key)
+
+    def __setitem__(self, key, value):
+        """
+        Add a key-value pair to the instance.
+        """
+        self._mapping[key] = value
+
+    def __delitem__(self, key):
+        """
+        Delete a key-value pair
+        """
+        del self._mapping[key]
+
+    def __len__(self):
+        """
+        Check the length of the mapping.
+        """
+        return len(self._mapping)
+
+    def __iter__(self):
+        """
+        Iterated through the keys.
+        """
+        return iter(self._mapping)
+
+    def __missing__(self, key):
+        """
+        Add a missing element.
+        """
+        if self._pass_key:
+            self[key] = value = self._default_factory(key)
+        else:
+            self[key] = value = self._default_factory()
+
+        return value
+
+    def __repr__(self):
+        """
+        Return a string representation of the object.
+        """
+        return six.u(
+            "AttrDefault({default_factory}, {pass_key}, {mapping})"
+        ).format(
+            default_factory=repr(self._default_factory),
+            pass_key=repr(self._pass_key),
+            mapping=repr(self._mapping),
+        )
+
+    def __getstate__(self):
+        """
+        Serialize the object.
+        """
+        return (
+            self._default_factory,
+            self._mapping,
+            self._sequence_type,
+            self._pass_key,
+            self._allow_invalid_attributes,
+        )
+
+    def __setstate__(self, state):
+        """
+        Deserialize the object.
+        """
+        (default_factory, mapping, sequence_type, pass_key,
+         allow_invalid_attributes) = state
+
+        self._setattr('_default_factory', default_factory)
+        self._setattr('_mapping', mapping)
+        self._setattr('_sequence_type', sequence_type)
+        self._setattr('_pass_key', pass_key)
+        self._setattr('_allow_invalid_attributes', allow_invalid_attributes)
+
+    @classmethod
+    def _constructor(cls, mapping, configuration):
+        """
+        A standardized constructor.
+        """
+        sequence_type, default_factory, pass_key = configuration
+        return cls(default_factory, mapping, sequence_type=sequence_type,
+                   pass_key=pass_key)

sdata-0.22.0/sdata/contrib/attrdict/dictionary.py

@@ -0,0 +1,60 @@
+"""
+A dict that implements MutableAttr.
+"""
+from .mixins import MutableAttr
+
+import six
+
+
+__all__ = ['AttrDict']
+
+
+class AttrDict(dict, MutableAttr):
+    """
+    A dict that implements MutableAttr.
+    """
+    def __init__(self, *args, **kwargs):
+        super(AttrDict, self).__init__(*args, **kwargs)
+
+        self._setattr('_sequence_type', tuple)
+        self._setattr('_allow_invalid_attributes', False)
+
+    def _configuration(self):
+        """
+        The configuration for an attrmap instance.
+        """
+        return self._sequence_type
+
+    def __getstate__(self):
+        """
+        Serialize the object.
+        """
+        return (
+            self.copy(),
+            self._sequence_type,
+            self._allow_invalid_attributes
+        )
+
+    def __setstate__(self, state):
+        """
+        Deserialize the object.
+        """
+        mapping, sequence_type, allow_invalid_attributes = state
+        self.update(mapping)
+        self._setattr('_sequence_type', sequence_type)
+        self._setattr('_allow_invalid_attributes', allow_invalid_attributes)
+
+    def __repr__(self):
+        return six.u('AttrDict({contents})').format(
+            contents=super(AttrDict, self).__repr__()
+        )
+
+    @classmethod
+    def _constructor(cls, mapping, configuration):
+        """
+        A standardized constructor.
+        """
+        attr = cls(mapping)
+        attr._setattr('_sequence_type', configuration)
+
+        return attr

sdata-0.22.0/sdata/contrib/attrdict/mapping.py

@@ -0,0 +1,100 @@
+"""
+An implementation of MutableAttr.
+"""
+try:
+    from collections.abc import Mapping
+except ImportError:
+    from collections import Mapping
+
+import six
+
+from .mixins import MutableAttr
+
+
+__all__ = ['AttrMap']
+
+
+class AttrMap(MutableAttr):
+    """
+    An implementation of MutableAttr.
+    """
+    def __init__(self, items=None, sequence_type=tuple):
+        if items is None:
+            items = {}
+        elif not isinstance(items, Mapping):
+            items = dict(items)
+
+        self._setattr('_sequence_type', sequence_type)
+        self._setattr('_mapping', items)
+        self._setattr('_allow_invalid_attributes', False)
+
+    def _configuration(self):
+        """
+        The configuration for an attrmap instance.
+        """
+        return self._sequence_type
+
+    def __getitem__(self, key):
+        """
+        Access a value associated with a key.
+        """
+        return self._mapping[key]
+
+    def __setitem__(self, key, value):
+        """
+        Add a key-value pair to the instance.
+        """
+        self._mapping[key] = value
+
+    def __delitem__(self, key):
+        """
+        Delete a key-value pair
+        """
+        del self._mapping[key]
+
+    def __len__(self):
+        """
+        Check the length of the mapping.
+        """
+        return len(self._mapping)
+
+    def __iter__(self):
+        """
+        Iterated through the keys.
+        """
+        return iter(self._mapping)
+
+    def __repr__(self):
+        """
+        Return a string representation of the object.
+        """
+        # sequence type seems like more trouble than it is worth.
+        # If people want full serialization, they can pickle, and in
+        # 99% of cases, sequence_type won't change anyway
+        return six.u("AttrMap({mapping})").format(mapping=repr(self._mapping))
+
+    def __getstate__(self):
+        """
+        Serialize the object.
+        """
+        return (
+            self._mapping,
+            self._sequence_type,
+            self._allow_invalid_attributes
+        )
+
+    def __setstate__(self, state):
+        """
+        Deserialize the object.
+        """
+        mapping, sequence_type, allow_invalid_attributes = state
+        self._setattr('_mapping', mapping)
+        self._setattr('_sequence_type', sequence_type)
+        self._setattr('_allow_invalid_attributes', allow_invalid_attributes)
+
+    @classmethod
+    def _constructor(cls, mapping, configuration):
+        """
+        A standardized constructor.
+        """
+        return cls(mapping, sequence_type=configuration)

sdata-0.22.0/sdata/contrib/attrdict/merge.py

@@ -0,0 +1,47 @@
+"""
+A right-favoring Mapping merge.
+"""
+try:
+    from collections.abc import Mapping
+except ImportError:
+    from collections import Mapping
+
+
+__all__ = ['merge']
+
+
+def merge(left, right):
+    """
+    Merge two mappings objects together, combining overlapping Mappings,
+    and favoring right-values
+
+    left: The left Mapping object.
+    right: The right (favored) Mapping object.
+
+    NOTE: This is not commutative (merge(a,b) != merge(b,a)).
+    """
+    merged = {}
+
+    left_keys = frozenset(left)
+    right_keys = frozenset(right)
+
+    # Items only in the left Mapping
+    for key in left_keys - right_keys:
+        merged[key] = left[key]
+
+    # Items only in the right Mapping
+    for key in right_keys - left_keys:
+        merged[key] = right[key]
+
+    # in both
+    for key in left_keys & right_keys:
+        left_value = left[key]
+        right_value = right[key]
+
+        if (isinstance(left_value, Mapping) and
+                isinstance(right_value, Mapping)):  # recursive merge
+            merged[key] = merge(left_value, right_value)
+        else:  # overwrite with right value
+            merged[key] = right_value
+
+    return merged