coveralls: 
[![Coverage Status](https://coveralls.io/builds/15870919/badge)](https://coveralls.io/builds/15870919)

Coverage increased (+0.3%) to 71.249% when pulling **a98af4a02c51348bf188bdb2c7124f27e94e6527 on jgrewe:property** into **2830914c8b5b67290d891d89aa28df344c5cacc7 on G-Node:master**.

JuliaSprenger: In general I am happy with this implementation, there are just a few cases, where I think the behaviour should be different

- providing a generator as  value should list the generated items, not the string version of the generator (eg ```odml.Property(name='prop', value=range(10))``` should contain a list of numbers, not a string)
- The automatic dtype conversion should not introduce a loss of information
```python
    prop1 = odml.Property(name='prop1', value=[3])
    prop2 = odml.Property(name='prop2', value=[3.5])
    prop1.merge(prop2)
```
should result in an Error rather than  ```prop1.value == [3,3]```

Also I suggest to also add a section.extend() function similar to the property.extend() function, buts that's probably a different issue.
JuliaSprenger: The ```strict``` option is a good idea, but I think it should be also available for section.merge and from there on be passed on to all merges of subsections and properties.

jgrewe: yes, agreed, would you mind to add it to issue #246, which was opened by Michi for the section append/extend/merge point you made
JuliaSprenger: Cool! I added a comment to the other issue. Then I think we can merge now.
diff --git a/.travis.yml b/.travis.yml
index 64226cd..ba6c228 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -25,28 +25,44 @@ matrix:
 #      env:
 #        - OSXENV=2.7
 
-before_install:
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then bash resources/install_osx_virtualenv.sh; fi
-
 install:
   - export PYVER=${TRAVIS_PYTHON_VERSION:0:1}
+  - if [ $PYVER = 3 ]; then
+      export PYCMD=python3;
+      export PIPCMD=pip3;
+    else
+      export PYCMD=python;
+      export PIPCMD=pip;
+    fi;
+
   - if [ $COVERALLS = 1 ]; then
-        pip install --upgrade coveralls;
+        $PIPCMD install --upgrade coveralls;
     fi;
+
   - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
-      which python;
-      source venv/bin/activate;
-      which python;
-    fi
-  - pip install lxml enum34 pyyaml rdflib
+      if [[ "$OSXENV" == "2.7" ]]; then
+        brew install python@2;
+        virtualenv venv -p python;
+        source venv/bin/activate;
+        export PYCMD=python;
+        export PIPCMD=pip;
+      else
+        brew upgrade python;
+        source venv/bin/activate;
+        export PYCMD=python3;
+        export PIPCMD=pip3;
+      fi;
+    fi;
+
+  - $PIPCMD install lxml enum34 pyyaml rdflib
 
 script:
-  - which python
-  - python setup.py build
+  - which $PYCMD
+  - $PYCMD setup.py build
   - if [ $COVERALLS = 1 ]; then
         coverage${PYVER} run --source=odml setup.py test && coverage${PYVER} report -m;
     else
-        python setup.py test;
+        $PYCMD setup.py test;
     fi;
 
 after_success:
diff --git a/odml/property.py b/odml/property.py
index b02bb1f..a81f0af 100644
--- a/odml/property.py
+++ b/odml/property.py
@@ -150,7 +150,35 @@ class BaseProperty(base.baseobject, Property):
 
     @property
     def value(self):
-        return self._value
+        """
+        Returns the value(s) stored in this property. Method always returns a list that
+        is a copy (!) of the stored value. Changing this list will NOT change the property.
+        For manipulation of the stored values use the append, extend, and direct access methods
+        (using brackets).
+
+        For example:
+        >> p = odml.Property("prop", value=[1, 2, 3])
+        >> print(p.value)
+        [1, 2, 3]
+        >> p.value.append(4)
+        >> print(p.value)
+        [1, 2, 3]
+
+        Individual values can be accessed and manipulated like this:
+        >>> print(p[0])
+        [1]
+        >> p[0] = 4
+        >> print(p[0])
+        [4]
+
+        The values can be iterated e.g. with a loop:
+        >> for v in p.value:
+              print(v)
+        4
+        2
+        3
+        """
+        return list(self._value)
 
     def value_str(self, index=0):
         """
@@ -164,6 +192,8 @@ class BaseProperty(base.baseobject, Property):
             Method ensures that the passed value(s) can be cast to the
             same dtype, i.e. that associated with this property or the
             inferred dtype of the first entry of the values list.
+
+        :param values an iterable that contains the values
         """
         for v in values:
             try:
@@ -172,18 +202,49 @@ class BaseProperty(base.baseobject, Property):
                 return False
         return True
 
+    def _convert_value_input(self, new_value):
+        """
+        This method ensures, that the passed new value is a list.
+        If new_value is a string, it will convert it to a list of
+        strings if the new_value contains embracing brackets.
+
+        returns list of new_value
+        """
+        if isinstance(new_value, str):
+            if new_value[0] == "[" and new_value[-1] == "]":
+                new_value = list(map(str.strip, new_value[1:-1].split(",")))
+            else:
+                new_value = [new_value]
+        elif isinstance(new_value, dict):
+            new_value = [str(new_value)]
+        elif hasattr(new_value, '__iter__') or hasattr(new_value, '__next__'):
+            new_value = list(new_value)
+        elif not isinstance(new_value, list):
+            new_value = [new_value]
+        else:
+            raise ValueError("odml.Property._convert_value_input: unsupported data type for values: %s" % type(new_value))
+        return new_value
+
     @value.setter
     def value(self, new_value):
+        """
+
+        Set the value of the property discarding any previous information.
+        Method will try to convert the passed value to the dtype of
+        the property and raise an ValueError, if not possible
+
+        :param new_value a single value or list of values.
+        """
         # Make sure boolean value 'False' gets through as well...
-        if new_value is None or new_value == "":
+        if new_value is None or (isinstance(new_value, (list, tuple, str)) and len(new_value) == 0):
+            self._value = []
             return
-        if isinstance(new_value, str):
-            if new_value[0] == "[" and new_value[-1] == "]":
-                new_value = new_value[1:-1].split(",")
-        if not isinstance(new_value, list):
-            new_value = [new_value]
+
+        new_value = self._convert_value_input(new_value)
+
         if self._dtype is None:
             self._dtype = dtypes.infer_dtype(new_value[0])
+
         if not self._validate_values(new_value):
             raise ValueError("odml.Property.value: passed values are not of "
                              "consistent type!")
@@ -195,6 +256,8 @@ class BaseProperty(base.baseobject, Property):
 
     @value_origin.setter
     def value_origin(self, new_value):
+        if new_value == "":
+            new_value = None
         self._value_origin = new_value
 
     @property
@@ -211,6 +274,8 @@ class BaseProperty(base.baseobject, Property):
 
     @unit.setter
     def unit(self, new_value):
+        if new_value == "":
+            new_value = None
         self._unit = new_value
 
     @property
@@ -219,6 +284,8 @@ class BaseProperty(base.baseobject, Property):
 
     @reference.setter
     def reference(self, new_value):
+        if new_value == "":
+            new_value = None
         self._reference = new_value
 
     @property
@@ -227,6 +294,8 @@ class BaseProperty(base.baseobject, Property):
 
     @definition.setter
     def definition(self, new_value):
+        if new_value == "":
+            new_value = None
         self._definition = new_value
 
     @property
@@ -235,6 +304,8 @@ class BaseProperty(base.baseobject, Property):
 
     @dependency.setter
     def dependency(self, new_value):
+        if new_value == "":
+            new_value = None
         self._dependency = new_value
 
     @property
@@ -243,6 +314,8 @@ class BaseProperty(base.baseobject, Property):
 
     @dependency_value.setter
     def dependency_value(self, new_value):
+        if new_value == "":
+            new_value = None
         self._dependency_value = new_value
 
     def remove(self, value):
@@ -267,16 +340,64 @@ class BaseProperty(base.baseobject, Property):
         """
         obj = super(BaseProperty, self).clone()
         obj._section = None
-        obj.value = self.value
+        obj.value = self._value
         return obj
 
-    def merge(self, property):
-        """
-        Stub that doesn't do anything for this class
-        """
-        pass
+    def merge(self, other, strict=True):
+        """Merges the property 'other' into self, if possible. Information
+        will be synchronized. Method will raise an ValueError when the
+        information in this property and the passed property are in
+        conflict.
+
+        :param other a Property
+        :param strict Bool value to indicate whether types should be
+        implicitly converted even when information may be lost. Default is True, i.e. no conversion, and error will be raised if types do not match.
 
-    def unmerge(self, property):
+        """
+        assert(isinstance(other, (BaseProperty)))
+        if strict and self.dtype != other.dtype:
+            raise ValueError("odml.Property.merge: src and dest dtypes do not match!")
+
+        if self.unit is not None and other.unit is not None and self.unit != other.unit:
+            raise ValueError("odml.Property.merge: src and dest units (%s, %s) do not match!"
+                             % (other.unit, self.unit))
+
+        if self.definition is not None and other.definition is not None:
+            self_def = ''.join(map(str.strip, self.definition.split())).lower()
+            other_def = ''.join(map(str.strip, other.definition.split())).lower()
+            if self_def != other_def:
+                raise ValueError("odml.Property.merge: src and dest definitions do not match!")
+
+        if self.uncertainty is not None and other.uncertainty is not None:
+            raise ValueError("odml.Property.merge: src and dest uncertainty both set and do not match!")
+
+        if self.reference is not None and other.reference is not None:
+            self_ref = ''.join(map(str.strip, self.reference.lower().split()))
+            other_ref = ''.join(map(str.strip, other.reference.lower().split()))
+            if self_ref != other_ref:
+                raise ValueError("odml.Property.merge: src and dest references are in conflict!")
+
+        if self.value_origin is not None and other.value_origin is not None:
+            self_ori = ''.join(map(str.strip, self.value_origin.lower().split()))
+            other_ori = ''.join(map(str.strip, other.value_origin.lower().split()))
+            if self_ori != other_ori:
+                raise ValueError("odml.Property.merge: src and dest value_origin are in conflict!")
+
+        if self.value_origin is None and other.value_origin is not None:
+            self.value_origin = other.value_origin
+        if self.uncertainty is None and other.uncertainty is not None:
+            self.uncertainty = other.uncertainty
+        if self.reference is None and other.reference is not None:
+            self.reference = other.reference
+        if self.definition is None and other.definition is not None:
+            self.definition = other.definition
+        if self.unit is None and other.unit is not None:
+            self.unit = other.unit
+
+        to_add = [v for v in other.value if v not in self._value]
+        self.extend(to_add, strict=strict)
+
+    def unmerge(self, other):
         """
         Stub that doesn't do anything for this class
         """
@@ -308,3 +429,62 @@ class BaseProperty(base.baseobject, Property):
 
     def __getitem__(self, key):
         return self._value[key]
+
+    def __setitem__(self, key, item):
+        if int(key) < 0 or int(key) > self.__len__():
+            raise IndexError("odml.Property.__setitem__: key %i invalid for array of length %i"
+                             % (int(key), self.__len__()))
+        try:
+            val = dtypes.get(item, self.dtype)
+            self._value[int(key)] = val
+        except Exception:
+            raise ValueError("odml.Property.__setitem__:  passed value cannot be converted to data type \'%s\'!" % self._dtype)
+
+    def extend(self, obj, strict=True):
+        """
+        Extend the list of values stored in this property by the passed values. Method will 
+        raise an ValueError, if values cannot be converted to the current dtype. One can also pass
+        another Property to append all values stored in that one. In this case units must match!
+
+        :param obj single value, list of values or Property
+        :param strict a Bool that controls whether dtypes must match. Default is True.
+        """
+        if isinstance(obj, BaseProperty):
+            if (obj.unit != self.unit):
+                raise ValueError("odml.Property.append: src and dest units (%s, %s) do not match!"
+                                 % (obj.unit, self.unit))
+            self.extend(obj.value)
+            return
+
+        if self.__len__() == 0:
+            self.value = obj
+            return
+
+        new_value = self._convert_value_input(obj)
+        if len(new_value) > 0 and strict and dtypes.infer_dtype(new_value[0]) != self.dtype:
+            raise ValueError("odml.Property.extend: passed value data type does not match dtype!");
+
+        if not self._validate_values(new_value):
+            raise ValueError("odml.Property.append: passed value(s) cannot be converted to "
+                             "data type \'%s\'!" % self._dtype)
+        self._value.extend([dtypes.get(v, self.dtype) for v in new_value])
+
+    def append(self, obj, strict=True):
+        """
+        Append a single value to the list of stored values. Method will raise an ValueError if 
+        the passed value cannot be converted to the current dtype.
+
+        :param obj the additional value.
+        :param strict a Bool that controls whether dtypes must match. Default is True.
+        """
+        new_value = self._convert_value_input(obj)
+        if len(new_value) > 1:
+            raise ValueError("odml.property.append: Use extend to add a list of values!")
+        if len(new_value) > 0 and strict and dtypes.infer_dtype(new_value[0]) != self.dtype:
+            raise ValueError("odml.Property.extend: passed value data type does not match dtype!");
+
+        if not self._validate_values(new_value):
+            raise ValueError("odml.Property.append: passed value(s) cannot be converted to "
+                             "data type \'%s\'!" % self._dtype)
+        self._value.append(dtypes.get(new_value[0], self.dtype))
+
diff --git a/odml/tools/dict_parser.py b/odml/tools/dict_parser.py
index 47ea641..0d2cdf0 100644
--- a/odml/tools/dict_parser.py
+++ b/odml/tools/dict_parser.py
@@ -80,8 +80,9 @@ class DictWriter:
 
                 if hasattr(prop, attr):
                     tag = getattr(prop, attr)
-
-                    if (tag == []) or tag:  # Even if 'value' is empty, allow '[]'
+                    if isinstance(tag, tuple):
+                        prop_dict[attr] = list(tag)
+                    elif (tag == []) or tag:  # Even if 'value' is empty, allow '[]'
                         prop_dict[attr] = tag
 
             props_seq.append(prop_dict)
@@ -187,7 +188,7 @@ class DictReader:
                     prop_attrs[attr] = _property[attr]
 
             prop = odmlfmt.Property.create(**prop_attrs)
-            prop._value = values
+            prop.value = values
             odml_props.append(prop)
 
         return odml_props
diff --git a/odml/tools/dumper.py b/odml/tools/dumper.py
index aa01b7a..dfb34a7 100644
--- a/odml/tools/dumper.py
+++ b/odml/tools/dumper.py
@@ -10,7 +10,7 @@ def get_props(obj, props):
         if hasattr(obj, p):
             x = getattr(obj, p)
             if x is not None:
-                if isinstance(x, list):
+                if isinstance(x, list) or isinstance(x, tuple):
                     out.append("%s=%s" % (p, to_csv(x)))
                 else:
                     out.append("%s=%s" % (p, repr(x)))
diff --git a/resources/install_osx_virtualenv.sh b/resources/install_osx_virtualenv.sh
index 6005fd4..c38ed9a 100644
--- a/resources/install_osx_virtualenv.sh
+++ b/resources/install_osx_virtualenv.sh
@@ -1,19 +1,26 @@
 #!/bin/bash
-
+echo %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 echo Running install_osx_virtalenv.sh
+python --version;
+echo travis python version:  $TRAVIS_PYTHON_VERSION
+echo %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
 
     brew update;
 
     if [[ "$OSXENV" == "2.7" ]]; then
+        echo python 2.7
         brew install python;
         virtualenv venv -p python;
         source venv/bin/activate;
     else
+        echo some other version 
         brew install python3;
         virtualenv venv -p python3;
         source venv/bin/activate;
+        export PYCMD=python3;
+        export PIPCMD=pip3;
     fi
 fi
 

Usage of python list as odml value circumvents dtype checks
Since we removed the odml.Value class and simply replaced it with a python `list`, this `list` provides of course methods like `append` which in turn ignores all the nice `dtype` checks we would like to have in place to keep odML values consistent.

As an example this currently works w/o any error:
```
p = odml.Property(name="example", dtype=odml.DType.int, value=[2, 4, 16, 23, 42])
p.value.append("lame ending")
```

diff --git a/test/test_property.py b/test/test_property.py
index debe542..03f51f9 100644
--- a/test/test_property.py
+++ b/test/test_property.py
@@ -13,9 +13,84 @@ class TestProperty(unittest.TestCase):
     def test_value(self):
         p = Property("property", 100)
         self.assertEqual(p.value[0], 100)
+        self.assertEqual(type(p.value), list)
 
-    def test_bool_conversion(self):
+        p.append(10)
+        self.assertEqual(len(p), 2)
+        self.assertRaises(ValueError, p.append, [1,2,3])
+
+        p.extend([20, 30, '40'])
+        self.assertEqual(len(p), 5)
+        with self.assertRaises(ValueError):
+            p.append('invalid')
+            p.extend(('5', 6, 7))
+
+        p2 = Property("property 2", 3)
+        self.assertRaises(ValueError, p.append, p2)
+        p.extend(p2)
+        self.assertEqual(len(p), 6)
+
+        p.value = None
+        self.assertEqual(len(p), 0)
+
+        p.value = [1, 2, 3]
+        p.value = ""
+        self.assertEqual(len(p), 0)
+
+        p.value = [1, 2, 3]
+        p.value = []
+        self.assertEqual(len(p), 0)
+
+        p.value = [1, 2, 3]
+        p.value = ()
+        self.assertEqual(len(p), 0)
+
+        p3 = Property("test", value=2, unit="Hz")
+        p4 = Property("test", value=5.5, unit="s")
+
+        with self.assertRaises(ValueError):
+            p3.append(p4)
+
+        p.value.append(5)
+        self.assertEqual(len(p.value), 0)
+        self.assertRaises(ValueError, p.append, 5.5)
+
+        p.append(5.5, strict=False)
+        self.assertEqual(len(p), 1)
+
+        self.assertRaises(ValueError, p.extend, [3.14, 6.28])
+        p.extend([3.14, 6.28], strict=False)
+        self.assertEqual(len(p), 3)
+
+        p5 = Property("test", value="a string")
+        p5.append("Freude")
+        self.assertEqual(len(p5), 2)
+        self.assertRaises(ValueError, p5.append, "[a, b, c]")
+        p5.extend("[a, b, c]")
+        self.assertEqual(len(p5), 5)
+
+        p6 = Property("test", {"name": "Marie", "name":"Johanna"})
+        self.assertEqual(len(p6), 1)
+
+    def test_get_set_value(self):
+        values = [1, 2, 3, 4, 5]
+        p = Property("property", value=values)
+
+        self.assertEqual(len(p), 5)
+        for s, d in zip(values, p.value):
+            self.assertEqual(s, d)
+
+        count = 0
+        for v in p:
+            count += 1
+        self.assertEqual(count, len(values))
 
+        p[0] = 10
+        self.assertEqual(p[0], 10)
+        with self.assertRaises(ValueError):
+            p[1] = 'stringval'
+
+    def test_bool_conversion(self):
         # Success tests
         p = Property(name='received', value=[1, 0, 1, 0, 1])
         assert(p.dtype == 'int')
@@ -47,7 +122,6 @@ class TestProperty(unittest.TestCase):
         assert(q.dtype == curr_type)
 
     def test_str_to_int_convert(self):
-
         # Success Test
         p = Property(name='cats_onboard', value=['3', '0', '1', '0', '8'])
         assert(p.dtype == 'string')
@@ -102,6 +176,8 @@ class TestProperty(unittest.TestCase):
         self.assertEqual(p.value_origin, None)
         p = Property("P", value_origin="V")
         self.assertEqual(p.value_origin, "V")
+        p.value_origin = ""
+        self.assertEqual(p.value_origin, None)
 
     def test_set_id(self):
         p = Property("P", id="79b613eb-a256-46bf-84f6-207df465b8f7")
@@ -110,7 +186,58 @@ class TestProperty(unittest.TestCase):
         Property("P", id="id")
         self.assertNotEqual(p.id, "id")
 
+    def test_merge(self):
+        p_dst = Property("p1", value=[1, 2, 3], unit="Hz", definition="Freude\t schoener\nGoetterfunken\n",
+                         reference="portal.g-node.org", uncertainty=0.0)
+        p_src = Property("p2", value=[2, 4, 6], unit="Hz", definition="FREUDE schoener GOETTERfunken")
+
+        test_p = p_dst.clone()
+        test_p.merge(p_src)
+        self.assertEqual(len(test_p.value), 5)
+
+        p_inv_unit = p_src.clone()
+        p_inv_unit.unit = 's'
+
+        p_inv_def = p_src.clone()
+        p_inv_def.definition = "Freunde schoender Goetterfunken"
+
+        p_inv_uncert = p_src.clone()
+        p_inv_uncert.uncertainty = 10.0
+
+        p_inv_ref = p_src.clone()
+        p_inv_ref.reference = "test"
+
+        test_p = p_dst.clone()
+        self.assertRaises(ValueError, test_p.merge, p_inv_unit)
+        self.assertRaises(ValueError, test_p.merge, p_inv_def)
+        self.assertRaises(ValueError, test_p.merge, p_inv_uncert)
+        self.assertRaises(ValueError, test_p.merge, p_inv_ref)
+
+        test_p.reference = None
+        test_p.merge(p_src)
+        self.assertEqual(test_p.reference, p_src.reference)
+
+        test_p.unit = ""
+        test_p.merge(p_src)
+        self.assertEqual(test_p.unit, p_src.unit)
+
+        test_p.uncertainty = None
+        test_p.merge(p_src)
+        self.assertEqual(test_p.uncertainty, p_src.uncertainty)
+
+        test_p.definition = ""
+        test_p.merge(p_src)
+        self.assertEqual(test_p.definition, p_src.definition)
+
+        double_p = Property("adouble", value=3.14)
+        int_p = Property("aint", value=3)
+        self.assertRaises(ValueError, double_p.merge, int_p)
+
+        int_p.merge(double_p, strict=False)
+        self.assertEqual(len(int_p), 2)
+
 if __name__ == "__main__":
     print("TestProperty")
     tp = TestProperty()
     tp.test_value()
+    tp.test_merge()
diff --git a/test/test_rdf_writer.py b/test/test_rdf_writer.py
index dca03c3..74fe195 100644
--- a/test/test_rdf_writer.py
+++ b/test/test_rdf_writer.py
@@ -100,7 +100,7 @@ class TestRDFWriter(unittest.TestCase):
         w.convert_to_rdf()
         self.assertEqual(len(list(w.g.subjects(predicate=RDF.li, object=Literal("val")))), 1)
 
-        doc.sections[0].properties[0].value.append("val2")
+        doc.sections[0].properties[0].append("val2")
         w = RDFWriter([doc])
         w.convert_to_rdf()
         self.assertEqual(len(list(w.g.subject_objects(predicate=RDF.li))), 2)

pip install -e .
parse_log_pytest
lxml pyyaml rdflib enum34
pytest
apt-get update apt-get install -y libxml2-dev libxslt1-dev lib32z1-dev
3.9
pytest --no-header -rA --tb=line --color=no -p no:cacheprovider -W ignore::DeprecationWarning
exceptiongroup==1.2.2
iniconfig==2.1.0
isodate @ file:///home/conda/feedstock_root/build_artifacts/isodate_1733230734792/work
lxml @ file:///croot/lxml_1737039601731/work
-e git+https://github.com/G-Node/python-odml.git@2830914c8b5b67290d891d89aa28df344c5cacc7#egg=odML
packaging==24.2
pluggy==1.5.0
pyparsing @ file:///croot/pyparsing_1731445506121/work
pytest==8.3.5
PyYAML @ file:///croot/pyyaml_1728657952215/work
rdflib @ file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_rdflib_1743255530/work/dist
tomli==2.2.1

name: python-odml
channels:
  - defaults
  - https://repo.anaconda.com/pkgs/main
  - https://repo.anaconda.com/pkgs/r
  - conda-forge
dependencies:
  - _libgcc_mutex=0.1=main
  - _openmp_mutex=5.1=1_gnu
  - ca-certificates=2025.2.25=h06a4308_0
  - enum34=1.1.10=py39h06a4308_0
  - icu=73.1=h6a678d5_0
  - isodate=0.7.2=pyhd8ed1ab_1
  - ld_impl_linux-64=2.40=h12ee557_0
  - libffi=3.4.4=h6a678d5_1
  - libgcc-ng=11.2.0=h1234567_1
  - libgomp=11.2.0=h1234567_1
  - libstdcxx-ng=11.2.0=h1234567_1
  - libxml2=2.13.5=hfdd30dd_0
  - libxslt=1.1.41=h097e994_0
  - lxml=5.3.0=py39h57af460_1
  - ncurses=6.4=h6a678d5_0
  - openssl=3.0.16=h5eee18b_0
  - pip=25.0=py39h06a4308_0
  - pyparsing=3.2.0=py39h06a4308_0
  - python=3.9.21=he870216_1
  - pyyaml=6.0.2=py39h5eee18b_0
  - rdflib=7.1.4=pyh29332c3_0
  - readline=8.2=h5eee18b_0
  - setuptools=75.8.0=py39h06a4308_0
  - sqlite=3.45.3=h5eee18b_0
  - tk=8.6.14=h39e8969_0
  - tzdata=2025a=h04d1e81_0
  - wheel=0.45.1=py39h06a4308_0
  - xz=5.6.4=h5eee18b_1
  - yaml=0.2.5=h7b6447c_0
  - zlib=1.2.13=h5eee18b_1
  - pip:
      - exceptiongroup==1.2.2
      - iniconfig==2.1.0
      - packaging==24.2
      - pluggy==1.5.0
      - pytest==8.3.5
      - tomli==2.2.1
prefix: /opt/conda/envs/python-odml

test/test_property.py::TestProperty::test_get_set_value test/test_property.py::TestProperty::test_merge test/test_property.py::TestProperty::test_value test/test_property.py::TestProperty::test_value_origin
test/test_rdf_writer.py::TestRDFWriter::test_adding_doc_to_the_hub test/test_rdf_writer.py::TestRDFWriter::test_adding_other_entities_properties test/test_rdf_writer.py::TestRDFWriter::test_adding_properties test/test_rdf_writer.py::TestRDFWriter::test_adding_repository test/test_rdf_writer.py::TestRDFWriter::test_adding_sections test/test_rdf_writer.py::TestRDFWriter::test_adding_values test/test_rdf_writer.py::TestRDFWriter::test_convert_to_rdf test/test_rdf_writer.py::TestRDFWriter::test_section_subclass
test/test_property.py::TestProperty::test_bool_conversion test/test_property.py::TestProperty::test_dtype test/test_property.py::TestProperty::test_name test/test_property.py::TestProperty::test_parent test/test_property.py::TestProperty::test_path test/test_property.py::TestProperty::test_set_id test/test_property.py::TestProperty::test_str_to_int_convert
odml/tools/dict_parser.py .travis.yml resources/install_osx_virtualenv.sh odml/tools/dumper.py odml/property.py
odml/tools/dict_parser.py .travis.yml resources/install_osx_virtualenv.sh odml/tools/dumper.py odml/property.py