diff --git a/pkgs/development/python-modules/pywbem/default.nix b/pkgs/development/python-modules/pywbem/default.nix
index fed159380b81..8e10fbb22581 100644
--- a/pkgs/development/python-modules/pywbem/default.nix
+++ b/pkgs/development/python-modules/pywbem/default.nix
@@ -15,12 +15,9 @@ buildPythonPackage rec {
   };
 
   patches = [
-    # fix timezone handling so the tests pass again. Can go when 0.11.0 is released
+    # fix timezone handling so the tests pass again. Can go when 0.10.1 is released
     # https://github.com/pywbem/pywbem/issues/755#issuecomment-327508681
-    (fetchpatch {
-      url = "https://github.com/pywbem/pywbem/commit/bb7fa19d636d999bf844d80939e155b8f212ef3e.patch";
-      sha256 = "1zd5f9qrb8rnaahmazkjnf3hqsc4f7n63z44k0wcwhz7fskpqza0";
-    })
+    ./make_cimdatetime_timezone_aware.patch
   ];
 
   propagatedBuildInputs = [ m2crypto ply pyyaml six ];
diff --git a/pkgs/development/python-modules/pywbem/make_cimdatetime_timezone_aware.patch b/pkgs/development/python-modules/pywbem/make_cimdatetime_timezone_aware.patch
new file mode 100644
index 000000000000..55fb9bbb12d7
--- /dev/null
+++ b/pkgs/development/python-modules/pywbem/make_cimdatetime_timezone_aware.patch
@@ -0,0 +1,491 @@
+From bb7fa19d636d999bf844d80939e155b8f212ef3e Mon Sep 17 00:00:00 2001
+From: Andreas Maier <maiera@de.ibm.com>
+Date: Fri, 23 Jun 2017 19:13:51 +0200
+Subject: [PATCH] Made CIMDateTime always timezone-aware, re-enabled
+ test_cim_types.py
+
+Details:
+- Ensured that 'CIMDateTime' objects for point in time values are
+  timezone-aware when supplied with a timezone-naive 'datetime'
+  object. This does not change the behavior, but increases code
+  clarity.
+- Clarified that in the documentation of 'CIMDateTime'.
+- Added testcases for CIMDateTime.
+- Re-enabled the testing of test_cim_types.py. Since its change
+  to using pytest it was not run because the test methods were
+  all static methods which apparently does not work. Not sure
+  this ever worked.
+
+Signed-off-by: Andreas Maier <maiera@de.ibm.com>
+---
+ docs/changes.rst            |   5 +
+ pywbem/cim_types.py         |  22 +--
+ testsuite/test_cim_types.py | 369 +++++++++++++++++++++++---------------------
+ 3 files changed, 207 insertions(+), 189 deletions(-)
+
+diff --git a/docs/changes.rst b/docs/changes.rst
+index 272ed30d..6fdfbcf4 100644
+--- a/docs/changes.rst
++++ b/docs/changes.rst
+@@ -72,6 +72,11 @@ Enhancements
+
+ * Added unit test for recorder. See issue #676
+
++* Ensured that `CIMDateTime` objects for point in time values are
++  timezone-aware when supplied with a timezone-naive `datetime` object.
++  This does not change the behavior, but increases code clarity.
++  Clarified that in the documentation of  `CIMDateTime`. See issue #698.
++
+ Bug fixes
+ ^^^^^^^^^
+
+diff --git a/pywbem/cim_types.py b/pywbem/cim_types.py
+index 6d1f140c..5ecc7707 100644
+--- a/pywbem/cim_types.py
++++ b/pywbem/cim_types.py
+@@ -74,6 +74,7 @@
+ import re
+ import warnings
+ import six
++import copy
+
+ from . import config
+
+@@ -294,9 +295,11 @@ def __init__(self, dtarg):
+             * A :term:`string` object will be
+               interpreted as CIM datetime format (see :term:`DSP0004`) and
+               will result in a point in time or a time interval.
+-            * A :class:`py:datetime.datetime` object must be timezone-aware
+-              (see :class:`~pywbem.MinutesFromUTC`) and will result in a point
+-              in time.
++            * A :class:`py:datetime.datetime` object will result in a point
++              in time. If the :class:`py:datetime.datetime` object is
++              timezone-aware (see :class:`~pywbem.MinutesFromUTC`), the
++              specified timezone will be used. Otherwise, a default timezone
++              of UTC will be assumed.
+             * A :class:`py:datetime.timedelta` object will result in a time
+               interval.
+             * Another :class:`~pywbem.CIMDateTime` object will be copied.
+@@ -342,14 +345,15 @@ def __init__(self, dtarg):
+                     raise ValueError('dtarg argument "%s" has an invalid CIM '
+                                      'datetime format' % dtarg)
+         elif isinstance(dtarg, datetime):
+-            self.__datetime = dtarg
++            if dtarg.tzinfo is None:
++                self.__datetime = dtarg.replace(tzinfo=MinutesFromUTC(0))
++            else:
++                self.__datetime = copy.copy(dtarg)
+         elif isinstance(dtarg, timedelta):
+-            self.__timedelta = dtarg
++            self.__timedelta = copy.copy(dtarg)
+         elif isinstance(dtarg, CIMDateTime):
+-            # pylint: disable=protected-access
+-            self.__datetime = dtarg.__datetime
+-            # pylint: disable=protected-access
+-            self.__timedelta = dtarg.__timedelta
++            self.__datetime = copy.copy(dtarg.datetime)
++            self.__timedelta = copy.copy(dtarg.timedelta)
+         else:
+             raise TypeError('dtarg argument "%s" has an invalid type: %s '
+                             '(expected datetime, timedelta, string, or '
+diff --git a/testsuite/test_cim_types.py b/testsuite/test_cim_types.py
+index 4ae354d3..b1f54d06 100755
+--- a/testsuite/test_cim_types.py
++++ b/testsuite/test_cim_types.py
+@@ -43,105 +43,99 @@ def integer_tuple(request):
+     return request.param
+
+
+-class TestIntegers:
+-    """
+-    Test CIM integer data type classes.
+-    """
+-
+-    @staticmethod
+-    def test_class_attrs_class(integer_tuple):
+-        """Test class attrs via class level"""
+-        obj_type, exp_cimtype, exp_minvalue, exp_maxvalue = integer_tuple
+-        assert obj_type.cimtype == exp_cimtype
+-        assert obj_type.minvalue == exp_minvalue
+-        assert obj_type.maxvalue == exp_maxvalue
+-
+-    @staticmethod
+-    def test_class_attrs_inst(integer_tuple):
+-        """Test class attrs via instance level"""
+-        obj_type, exp_cimtype, exp_minvalue, exp_maxvalue = integer_tuple
+-        obj = obj_type(42)
+-        assert obj.cimtype == exp_cimtype
+-        assert obj.minvalue == exp_minvalue
+-        assert obj.maxvalue == exp_maxvalue
+-
+-    @staticmethod
+-    def test_inheritance(integer_tuple):
+-        """Test inheritance"""
+-        obj_type = integer_tuple[0]
+-        obj = obj_type(42)
+-        assert isinstance(obj, obj_type)
+-        assert isinstance(obj, CIMType)
+-        assert isinstance(obj, CIMInt)
+-        assert not isinstance(obj, CIMFloat)
+-
+-    @staticmethod
+-    def test_init_int(integer_tuple):
+-        """Test initialization from integer value"""
+-        obj_type = integer_tuple[0]
+-        obj = obj_type(42)
+-        assert obj == 42
+-
+-    @staticmethod
+-    def test_init_str(integer_tuple):
+-        """Test initialization from string value"""
+-        obj_type = integer_tuple[0]
+-        obj = obj_type('42')
+-        assert obj == 42
+-
+-    @staticmethod
+-    def test_init_str_base10(integer_tuple):
+-        """Test initialization from string value with base 10"""
+-        obj_type = integer_tuple[0]
+-        obj = obj_type('42', 10)
+-        assert obj == 42
+-
+-    @staticmethod
+-    def test_init_str_base16(integer_tuple):
+-        """Test initialization from string value with base 16"""
+-        obj_type = integer_tuple[0]
+-        obj = obj_type('2A', 16)
+-        assert obj == 42
+-
+-    @staticmethod
+-    def test_init_minimum(integer_tuple):
+-        """Test initialization from integer value at minimum"""
+-        obj_type = integer_tuple[0]
+-        exp_minvalue = integer_tuple[2]
+-        obj = obj_type(exp_minvalue)
+-        assert obj == exp_minvalue
+-
+-    @staticmethod
+-    def test_init_maximum(integer_tuple):
+-        """Test initialization from integer value at maximum"""
+-        obj_type = integer_tuple[0]
+-        exp_maxvalue = integer_tuple[3]
+-        obj = obj_type(exp_maxvalue)
+-        assert obj == exp_maxvalue
+-
+-    @staticmethod
+-    def test_init_too_low(integer_tuple):
+-        """Test initialization from integer value below minimum"""
+-        obj_type = integer_tuple[0]
+-        exp_minvalue = integer_tuple[2]
+-        try:
+-            obj_type(exp_minvalue - 1)
+-        except ValueError:
+-            pass
+-        else:
+-            raise AssertionError("ValueError was not raised.")
+-
+-    @staticmethod
+-    def test_init_too_high(integer_tuple):
+-        """Test initialization from integer value above maximum"""
+-        obj_type = integer_tuple[0]
+-        exp_maxvalue = integer_tuple[3]
+-        try:
+-            obj_type(exp_maxvalue + 1)
+-        except ValueError:
+-            pass
+-        else:
+-            raise AssertionError("ValueError was not raised.")
++def test_integer_class_attrs_class(integer_tuple):
++    """Test class attrs via class level"""
++    obj_type, exp_cimtype, exp_minvalue, exp_maxvalue = integer_tuple
++    assert obj_type.cimtype == exp_cimtype
++    assert obj_type.minvalue == exp_minvalue
++    assert obj_type.maxvalue == exp_maxvalue
++
++
++def test_integer_class_attrs_inst(integer_tuple):
++    """Test class attrs via instance level"""
++    obj_type, exp_cimtype, exp_minvalue, exp_maxvalue = integer_tuple
++    obj = obj_type(42)
++    assert obj.cimtype == exp_cimtype
++    assert obj.minvalue == exp_minvalue
++    assert obj.maxvalue == exp_maxvalue
++
++
++def test_integer_inheritance(integer_tuple):
++    """Test inheritance"""
++    obj_type = integer_tuple[0]
++    obj = obj_type(42)
++    assert isinstance(obj, obj_type)
++    assert isinstance(obj, CIMType)
++    assert isinstance(obj, CIMInt)
++    assert not isinstance(obj, CIMFloat)
++
++
++def test_integer_init_int(integer_tuple):
++    """Test initialization from integer value"""
++    obj_type = integer_tuple[0]
++    obj = obj_type(42)
++    assert obj == 42
++
++
++def test_integer_init_str(integer_tuple):
++    """Test initialization from string value"""
++    obj_type = integer_tuple[0]
++    obj = obj_type('42')
++    assert obj == 42
++
++
++def test_integer_init_str_base10(integer_tuple):
++    """Test initialization from string value with base 10"""
++    obj_type = integer_tuple[0]
++    obj = obj_type('42', 10)
++    assert obj == 42
++
++
++def test_integer_init_str_base16(integer_tuple):
++    """Test initialization from string value with base 16"""
++    obj_type = integer_tuple[0]
++    obj = obj_type('2A', 16)
++    assert obj == 42
++
++
++def test_integer_init_minimum(integer_tuple):
++    """Test initialization from integer value at minimum"""
++    obj_type = integer_tuple[0]
++    exp_minvalue = integer_tuple[2]
++    obj = obj_type(exp_minvalue)
++    assert obj == exp_minvalue
++
++
++def test_integer_init_maximum(integer_tuple):
++    """Test initialization from integer value at maximum"""
++    obj_type = integer_tuple[0]
++    exp_maxvalue = integer_tuple[3]
++    obj = obj_type(exp_maxvalue)
++    assert obj == exp_maxvalue
++
++
++def test_integer_init_too_low(integer_tuple):
++    """Test initialization from integer value below minimum"""
++    obj_type = integer_tuple[0]
++    exp_minvalue = integer_tuple[2]
++    try:
++        obj_type(exp_minvalue - 1)
++    except ValueError:
++        pass
++    else:
++        raise AssertionError("ValueError was not raised.")
++
++
++def test_integer_init_too_high(integer_tuple):
++    """Test initialization from integer value above maximum"""
++    obj_type = integer_tuple[0]
++    exp_maxvalue = integer_tuple[3]
++    try:
++        obj_type(exp_maxvalue + 1)
++    except ValueError:
++        pass
++    else:
++        raise AssertionError("ValueError was not raised.")
+
+
+ #
+@@ -164,47 +158,41 @@ def real_tuple(request):
+     return request.param
+
+
+-class TestReals:
+-    """
+-    Test CIM real data type classes.
+-    """
+-
+-    @staticmethod
+-    def test_class_attrs_class(real_tuple):
+-        """Test class attrs via class level"""
+-        obj_type, exp_cimtype = real_tuple
+-        assert obj_type.cimtype == exp_cimtype
+-
+-    @staticmethod
+-    def test_class_attrs_inst(real_tuple):
+-        """Test class attrs via instance level"""
+-        obj_type, exp_cimtype = real_tuple
+-        obj = obj_type(42)
+-        assert obj.cimtype == exp_cimtype
+-
+-    @staticmethod
+-    def test_inheritance(real_tuple):
+-        """Test inheritance"""
+-        obj_type = real_tuple[0]
+-        obj = obj_type(42)
+-        assert isinstance(obj, obj_type)
+-        assert isinstance(obj, CIMType)
+-        assert isinstance(obj, CIMFloat)
+-        assert not isinstance(obj, CIMInt)
+-
+-    @staticmethod
+-    def test_init_float(real_tuple):
+-        """Test initialization from floating point value"""
+-        obj_type = real_tuple[0]
+-        obj = obj_type(42.0)
+-        assert obj == 42.0
+-
+-    @staticmethod
+-    def test_init_str(real_tuple):
+-        """Test initialization from string value"""
+-        obj_type = real_tuple[0]
+-        obj = obj_type('42.0')
+-        assert obj == 42.0
++def test_real_class_attrs_class(real_tuple):
++    """Test class attrs via class level"""
++    obj_type, exp_cimtype = real_tuple
++    assert obj_type.cimtype == exp_cimtype
++
++
++def test_real_class_attrs_inst(real_tuple):
++    """Test class attrs via instance level"""
++    obj_type, exp_cimtype = real_tuple
++    obj = obj_type(42)
++    assert obj.cimtype == exp_cimtype
++
++
++def test_real_inheritance(real_tuple):
++    """Test inheritance"""
++    obj_type = real_tuple[0]
++    obj = obj_type(42)
++    assert isinstance(obj, obj_type)
++    assert isinstance(obj, CIMType)
++    assert isinstance(obj, CIMFloat)
++    assert not isinstance(obj, CIMInt)
++
++
++def test_real_init_float(real_tuple):
++    """Test initialization from floating point value"""
++    obj_type = real_tuple[0]
++    obj = obj_type(42.0)
++    assert obj == 42.0
++
++
++def test_real_init_str(real_tuple):
++    """Test initialization from string value"""
++    obj_type = real_tuple[0]
++    obj = obj_type('42.0')
++    assert obj == 42.0
+
+
+ #
+@@ -271,6 +259,26 @@ def test_init_str(real_tuple):
+         '20140924193040.654321+120'
+     ),
+     (
++        datetime(year=2014, month=9, day=24, hour=19, minute=30, second=40,
++                 microsecond=654321, tzinfo=MinutesFromUTC(0)),
++        'timestamp',
++        datetime(year=2014, month=9, day=24, hour=19, minute=30, second=40,
++                 microsecond=654321, tzinfo=MinutesFromUTC(0)),
++        None,
++        0,
++        '20140924193040.654321+000'
++    ),
++    (
++        datetime(year=2014, month=9, day=24, hour=19, minute=30, second=40,
++                 microsecond=654321),
++        'timestamp',
++        datetime(year=2014, month=9, day=24, hour=19, minute=30, second=40,
++                 microsecond=654321, tzinfo=MinutesFromUTC(0)),
++        None,
++        0,
++        '20140924193040.654321+000'
++    ),
++    (
+         '20140924193040.654321+120',
+         'timestamp',
+         datetime(year=2014, month=9, day=24, hour=19, minute=30, second=40,
+@@ -325,46 +333,47 @@ def datetime_init_tuple(request):
+     return request.param
+
+
+-class TestDatetime:
+-    """
+-    Test CIM real data type classes.
+-    """
+-
+-    @staticmethod
+-    def test_class_attrs_class():
+-        """Test class attrs via class level"""
+-        assert CIMDateTime.cimtype == 'datetime'
+-
+-    @staticmethod
+-    def test_class_attrs_inst():
+-        """Test class attrs via instance level"""
+-        obj = CIMDateTime('00000000000000.000000:000')
+-        assert obj.cimtype == 'datetime'
+-
+-    @staticmethod
+-    def test_inheritance():
+-        """Test inheritance"""
+-        obj = CIMDateTime('00000000000000.000000:000')
+-        assert isinstance(obj, CIMDateTime)
+-        assert isinstance(obj, CIMType)
+-        assert not isinstance(obj, CIMFloat)
+-        assert not isinstance(obj, CIMInt)
+-
+-    @staticmethod
+-    def test_init(datetime_init_tuple):
+-        """Test initialization from all input types"""
+-        (dtarg, exp_kind, exp_datetime, exp_timedelta, exp_minutesfromutc,
+-         exp_str) = datetime_init_tuple
+-        try:
+-            obj = CIMDateTime(dtarg)
+-        except Exception as exc:
+-            assert isinstance(exc, exp_kind)
+-        else:
+-            assert obj.is_interval == (exp_kind == 'interval')
+-            assert obj.datetime == exp_datetime
+-            assert obj.timedelta == exp_timedelta
+-            assert obj.minutes_from_utc == exp_minutesfromutc
+-            assert str(obj) == exp_str
++def test_datetime_class_attrs_class():
++    """Test class attrs via class level"""
++    assert CIMDateTime.cimtype == 'datetime'
++
++
++def test_datetime_class_attrs_inst():
++    """Test class attrs via instance level"""
++    obj = CIMDateTime('00000000000000.000000:000')
++    assert obj.cimtype == 'datetime'
++
++
++def test_datetime_inheritance():
++    """Test inheritance"""
++    obj = CIMDateTime('00000000000000.000000:000')
++    assert isinstance(obj, CIMDateTime)
++    assert isinstance(obj, CIMType)
++    assert not isinstance(obj, CIMFloat)
++    assert not isinstance(obj, CIMInt)
++
++
++def test_datetime_init(datetime_init_tuple):
++    """Test initialization from all input types"""
++    (dtarg, exp_kind, exp_datetime, exp_timedelta, exp_minutesfromutc,
++     exp_str) = datetime_init_tuple
++    try:
++        obj = CIMDateTime(dtarg)
++    except Exception as exc:
++        assert isinstance(exc, exp_kind)
++    else:
++        assert obj.is_interval == (exp_kind == 'interval')
++        assert obj.datetime == exp_datetime
++        if obj.datetime is not None:
++            assert isinstance(obj.datetime, datetime)
++            # We ensure that the datetime is always timezone-aware:
++            assert obj.datetime.tzinfo is not None
++        assert obj.timedelta == exp_timedelta
++        if obj.timedelta is not None:
++            assert isinstance(obj.timedelta, timedelta)
++        assert obj.minutes_from_utc == exp_minutesfromutc
++        assert str(obj) == exp_str
++
+
+ # TODO: Add testcases for get_local_utcoffset()
+ # TODO: Add testcases for now()