sdata 0.23.3__tar.gz → 0.24.0__tar.gz

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

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

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

@@ -1,7 +1,7 @@
 # -*-coding: utf-8-*-
 from __future__ import division
 
-__version__ = '0.23.3'
+__version__ = '0.24.0'
 __revision__ = None
 __version_info__ = tuple([int(num) for num in __version__.split('.')])
 

{sdata-0.23.3 → 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]
@@ -166,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
@@ -212,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
 
@@ -520,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
@@ -1018,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")
@@ -1274,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.3 → 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.3 → sdata-0.24.0}/sdata/metadata.py

@@ -455,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.3 → sdata-0.24.0/sdata.egg-info}/PKG-INFO

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

{sdata-0.23.3 → 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")