sdata 0.23.2__tar.gz → 0.24.0__tar.gz

{sdata-0.23.2/sdata.egg-info → sdata-0.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sdata
-Version: 0.23.2
+Version: 0.24.0
 Summary: a structured data format
 Home-page: https://github.com/lepy/sdata
 Author: Lepy

{sdata-0.23.2 → sdata-0.24.0}/sdata/__init__.py

@@ -1,7 +1,7 @@
 # -*-coding: utf-8-*-
 from __future__ import division
 
-__version__ = '0.23.2'
+__version__ = '0.24.0'
 __revision__ = None
 __version_info__ = tuple([int(num) for num in __version__.split('.')])
 
@@ -14,8 +14,8 @@ import uuid
 import logging
 
 # fix "ValueError: unsupported pickle protocol: 5"
-import pickle
-pickle.HIGHEST_PROTOCOL = 4
+#import pickle
+#pickle.HIGHEST_PROTOCOL = 4
 import pandas
 
 from sdata.metadata import Metadata, Attribute

{sdata-0.23.2 → sdata-0.24.0}/sdata/data.py

@@ -24,6 +24,7 @@ import json
 import hashlib
 import base64
 import requests
+import re
 from tabulate import tabulate
 from sdata.contrib.sqlitedict import SqliteDict
 
@@ -46,6 +47,24 @@ except:
 def uuid_from_str(name):
     return uuid.uuid3(uuid.NAMESPACE_DNS, name)
 
+def nameunit_from_colname(column_name):
+    """
+
+    """
+    #pattern = r"^(.*?)\s*\[(.+)\]$"
+    pattern = r"^(.*?)\s*\[([^\]]+)\]$"
+
+    # Anwenden des Regex
+    match = re.match(pattern, column_name)
+
+    if match:
+        name = match.group(1)  # Der Name der Spalte
+        unit = match.group(2)  # Die Einheit
+    else:
+        name = column_name
+        unit = "-"
+    return name.strip(), unit.strip()
+
 class Data(object):
     """Base sdata object"""
     ATTR_NAMES = []
@@ -61,6 +80,7 @@ class Data(object):
     SDATA_CLASS = "!sdata_class"
     SDATA_PROJECT = "!sdata_project"
     SDATA_URL = "!sdata_url"
+    SDATA_COLUMN = "!sdata_column"
 
     SDATA_ATTRIBUTES = [SDATA_VERSION, SDATA_NAME, SDATA_UUID, SDATA_SUUID, SDATA_CLASS, SDATA_PARENT, SDATA_PROJECT,
                         SDATA_CTIME, SDATA_MTIME, SDATA_URL]
@@ -104,6 +124,7 @@ class Data(object):
         self.metadata.add(self.SDATA_CTIME, now_utc_str(), dtype="str", description="creation date")
         self.metadata.add(self.SDATA_MTIME, now_utc_str(), dtype="str", description="modification date")
         self.metadata.add(self.SDATA_URL, "", dtype="str", description="url of the data object")
+        self.metadata.add(self.SDATA_PROJECT, "", dtype="str", description="project name")
 
         metadata = kwargs.get("metadata")
         if metadata is not None:
@@ -130,7 +151,8 @@ class Data(object):
         self.table = kwargs.get("table", None)
         self._description = ""
         self.description = kwargs.get("description", "")
-        self.project = kwargs.get("project", "")
+        self.project = kwargs.get("project", "N.N.")
+        self.metadata.add(self.SDATA_PROJECT, self.project, dtype="str", description="project name")
 
         if (kwargs.get("uuid")=="" or kwargs.get("uuid") is not None) and not self.metadata.get(self.SDATA_UUID).value and kwargs.get("uuid")!="hash":
             # logger.info("uuid in kwargs")
@@ -164,6 +186,10 @@ class Data(object):
         if "sname" in kwargs:
             self.sname = kwargs.get("sname")
 
+
+        if "parent" in kwargs:
+            self.metadata.add(self.SDATA_PARENT, kwargs.get("parent"))
+
     def gen_suuid(self):
         self.suuid = sdata.SUUID(self.__class__.__name__, self.name, huuid=self.uuid).idstr
         self.sname = sdata.SUUID(self.__class__.__name__, self.name, huuid=self.uuid).sname
@@ -210,6 +236,10 @@ class Data(object):
         self._set_uuid(suuid.huuid)
         return self
 
+    @property
+    def m(self):
+        return self.metadata
+
     def update_mtime(self):
         """update modification time
 
@@ -518,6 +548,49 @@ class Data(object):
             data.to_folder(exportpath, dtype=dtype)
         return path
 
+    def set_column_metadata(self):
+        """convert 'Force [N]' -> 'Force', 'N'
+
+        add Attribute for each column
+
+            sdata_column_0: value="Force", unit="N"
+            sdata_column_1
+            ...
+            sdata_column_n
+
+
+        """
+        if self.df is None:
+            return
+        for i, col in enumerate(self.df.columns):
+            name, unit = nameunit_from_colname(col)
+            scolname = f"{self.SDATA_COLUMN}_{i}"
+            self.metadata.add(scolname, value=name, unit=unit, label=col)
+
+    def set_columnnames_from_metadata(self):
+        """Use '!sdata_column_*' to reformat columns names
+
+                '!sdata_column_0',  value='Force', unit='N' -> 'Force [N]'
+
+                > f'{name} [{unit}]'
+
+        """
+        if self.df is None:
+            return
+
+        cols = []
+        for i, col in enumerate(self.df.columns):
+            scolname = f"{self.SDATA_COLUMN}_{i}"
+            attr = self.metadata.get(scolname)
+            if attr is None:
+                name, unit = nameunit_from_colname(col)
+            else:
+                name = attr.value
+                unit = attr.unit
+            new_colname = f'{name} [{unit}]'
+            cols.append(new_colname)
+        self.df.columns = cols
+
     @classmethod
     def from_folder(cls, path):
         """sdata object instance
@@ -1016,15 +1089,19 @@ class Data(object):
         :param sep: separator (default=";")
         :return: sdata.Data
         """
+        if s is None and filepath is None:
+            logging.error("specify string if filepath")
+            return
         data = cls()
         df = None
         try:
             if filepath:
                 df = pd.read_csv(filepath, sep=";", comment="#", index_col=0)
                 sio = open(filepath, "r")
+                sio.seek(0)
             elif s is not None:
                 sio = StringIO(s)
-                pd.read_csv(sio, sep=";", comment="#")
+                df = pd.read_csv(sio, sep=";", comment="#")
                 sio.seek(0)
             else:
                 logger.error("data.from_csv: no csv data available")
@@ -1272,7 +1349,7 @@ class Data(object):
         :return: Data
         """
         data = copy.deepcopy(self)
-        data.metadata.add(self.SDATA_PARENT, self.uuid)
+        data.metadata.add(self.SDATA_PARENT, self.suuid)
         data.metadata.add(self.SDATA_UUID, self.gen_uuid())
         data.metadata.add(self.SDATA_MTIME, now_utc_str(), dtype="str")
         if "uuid" in kwargs:

{sdata-0.23.2 → sdata-0.24.0}/sdata/image.py

@@ -236,6 +236,10 @@ class Image(Data):
             d = json.loads(json_string)
         return d
 
+    @property
+    def basename(self):
+        return os.path.basename(self.url)
+
     def saveas(self, filepath, rename=True, random=True, **kwargs):
         """save image
 

{sdata-0.23.2 → sdata-0.24.0}/sdata/metadata.py

@@ -59,7 +59,7 @@ class Attribute(object):
     DTYPES_INV = {v: k for k, v in DTYPES.items()}
 
     def __init__(self, name, value, **kwargs):
-        """Attribute
+        """Attribute(name, value, dtype=str, unit="-", description="", label="", required=False)
         :param name
         :param value
         :param dtype ['float', 'int', 'str', 'timestamp', 'uuid?', 'unicode?']
@@ -303,10 +303,15 @@ class Metadata(object):
         required_attributes = [(attr.name, attr) for attr in self.attributes.values() if attr.required is True]
         return SortedDict(required_attributes)
 
+    def add_attribute(self, attr, **kwargs):
+        """set Attribute"""
+        prefix = kwargs.get("prefix", "")
+        self._attributes[prefix + attr.name] = attr
+
     def set_attr(self, name="N.N.", value=None, **kwargs):
         """set Attribute"""
         prefix = kwargs.get("prefix", "")
-        if isinstance(name, Attribute):
+        if isinstance(name, Attribute) or "Attribute" in name.__class__.__name__:
             attr = name # name is the Attribute!
         else:
             attr = self.get_attr(prefix + name) or Attribute(name, value, **kwargs)
@@ -419,6 +424,13 @@ class Metadata(object):
             d[attr.name] = attr.value
         return d
 
+    def get_dict(self):
+        """get user attribute as dict"""
+        d = {}
+        for attr in self.attributes.values():
+            d[attr.name] = attr.value
+        return d
+
     def _to_dataframe(self, attributes):
         """create dataframe from attributes"""
         d = self._to_dict(attributes)
@@ -443,6 +455,22 @@ class Metadata(object):
         """create dataframe for user attributes"""
         return self._to_dataframe(self.user_attributes)
 
+    @property
+    def dft(self):
+        """create transposed dataframe for sdata attributes"""
+        mt = self.df[["value"]].transpose(copy=True)
+        mt.index = [self.get("!sdata_sname").value]
+        return mt
+
+    def get_dft(self, index_name=None):
+        """create transposed dataframe for sdata attributes"""
+        if index_name is None:
+            index_name = "!sdata_sname"
+        mt = self.df[["value"]].transpose(copy=True)
+        mt.index = [self.get(index_name).value]
+        return mt
+
+
     @property
     def sdf(self):
         """create dataframe for sdata attributes"""

{sdata-0.23.2 → sdata-0.24.0/sdata.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sdata
-Version: 0.23.2
+Version: 0.24.0
 Summary: a structured data format
 Home-page: https://github.com/lepy/sdata
 Author: Lepy

{sdata-0.23.2 → sdata-0.24.0}/tests/test_data.py

@@ -25,6 +25,28 @@ def test_data():
 
     assert data2.uuid == uuidobj.hex
 
+def test_column_units():
+    columns = ["Länge [mm]", "Breite [cm]", "wtf", "Spannung[MPa]"]
+    df = pd.DataFrame(columns=columns)
+    d = sdata.Data(table=df)
+    d.set_column_metadata()
+    print(d.sdf)
+    c0 = d.m.get("!sdata_column_0")
+
+    assert "!sdata_column_3" in d.m.keys()
+    assert c0
+    print(c0.value, c0.unit)
+    assert c0.value == "Länge"
+    assert c0.unit == "mm"
+
+    c3 = d.m.get("!sdata_column_3")
+    print(c3.value, c3.unit)
+    assert c3.value == "Spannung"
+    assert c3.unit == "MPa"
+    c4 = d.m.get("!sdata_column_4")
+    assert c4 is None
+
+
 def test_group():
 
     data1 = sdata.Data(name="data1", uuid="38b26864e7794f5182d38459bab8584f")