systemd-python: tidy up import names in journal

[elogind.git] / src / python-systemd / journal.py

diff --git a/src/python-systemd/journal.py b/src/python-systemd/journal.py
index 533a8754a4f8ca6b09d7fb5fcc6322b222415af4..a50922ca3de274a0bff8e96e8d1a4f63ce3bb7be 100644 (file)
--- a/src/python-systemd/journal.py
+++ b/src/python-systemd/journal.py
@@ -19,13 +19,16 @@
 #  You should have received a copy of the GNU Lesser General Public License
 #  along with systemd; If not, see <http://www.gnu.org/licenses/>.
 
-import datetime
-import functools
-import sys
-import uuid
+import sys as _sys
+import datetime as _datetime
+import functools as _functools
+import uuid as _uuid
 import traceback as _traceback
 import os as _os
+from os import SEEK_SET, SEEK_CUR, SEEK_END
 import logging as _logging
+if _sys.version_info >= (3,):
+    from collections import ChainMap
 from syslog import (LOG_EMERG, LOG_ALERT, LOG_CRIT, LOG_ERR,
                     LOG_WARNING, LOG_NOTICE, LOG_INFO, LOG_DEBUG)
 from ._journal import sendv, stream_fd
@@ -33,10 +36,12 @@ from ._reader import (_Journal, NOP, APPEND, INVALIDATE,
                       LOCAL_ONLY, RUNTIME_ONLY, SYSTEM_ONLY)
 from . import id128 as _id128
 
-_MONOTONIC_CONVERTER = lambda x: datetime.timedelta(microseconds=float(x))
-_REALTIME_CONVERTER = lambda x: datetime.datetime.fromtimestamp(float(x)/1E6)
+_MONOTONIC_CONVERTER = lambda x: _datetime.timedelta(microseconds=float(x))
+_REALTIME_CONVERTER = lambda x: _datetime.datetime.fromtimestamp(float(x)/1E6)
 DEFAULT_CONVERTERS = {
-    'MESSAGE_ID': uuid.UUID,
+    'MESSAGE_ID': _uuid.UUID,
+    '_MACHINE_ID': _uuid.UUID,
+    '_BOOT_ID': _uuid.UUID,
     'PRIORITY': int,
     'LEADER': int,
     'SESSION_ID': int,
@@ -68,15 +73,16 @@ DEFAULT_CONVERTERS = {
     'COREDUMP_TIMESTAMP': _REALTIME_CONVERTER,
 }
 
-if sys.version_info >= (3,):
-    _convert_unicode = functools.partial(str, encoding='utf-8')
+if _sys.version_info >= (3,):
+    _convert_unicode = _functools.partial(str, encoding='utf-8')
 else:
-    _convert_unicode = functools.partial(unicode, encoding='utf-8')
+    _convert_unicode = _functools.partial(unicode, encoding='utf-8')
 
 class Journal(_Journal):
     def __init__(self, converters=None, *args, **kwargs):
         super(Journal, self).__init__(*args, **kwargs)
         if sys.version_info >= (3,3):
+        if _sys.version_info >= (3,3):
             self.converters = ChainMap()
             if converters is not None:
                 self.converters.maps.append(converters)
@@ -90,7 +96,7 @@ class Journal(_Journal):
     def _convert_field(self, key, value):
         try:
             result = self.converters[key](value)
-        except KeyError:
+        except:
             # Default conversion in unicode
             try:
                 result = _convert_unicode(value)
@@ -101,20 +107,36 @@ class Journal(_Journal):
 
     def _convert_entry(self, entry):
         result = {}
-        for key, value in entry.iteritems():
+        for key, value in entry.items():
             if isinstance(value, list):
                 result[key] = [self._convert_field(key, val) for val in value]
             else:
                 result[key] = self._convert_field(key, value)
         return result
 
-    def get_next(self, *args, **kwargs):
+    def add_match(self, *args, **kwargs):
+        args = list(args)
+        args.extend(_make_line(key, val) for key, val in kwargs.items())
+        for arg in args:
+            super(Journal, self).add_match(arg)
+
+    def get_next(self, skip=1):
         return self._convert_entry(
-            super(Journal, self).get_next(*args, **kwargs))
+            super(Journal, self).get_next(skip))
 
-    def query_unique(self, key, *args, **kwargs):
+    def query_unique(self, key):
         return set(self._convert_field(key, value)
-            for value in super(Journal, self).query_unique(key, *args, **kwargs))
+            for value in super(Journal, self).query_unique(key))
+
+    def seek_realtime(self, timestamp):
+        if isinstance(realtime, _datetime.datetime):
+            timestamp = float(timestamp.strftime("%s.%f"))
+        return super(Journal, self).seek_realtime(timestamp)
+
+    def seek_monotonic(self, timestamp, bootid=None):
+        if isinstance(monotonic, _datetime.timedelta):
+            timestamp = timestamp.totalseconds()
+        return super(Journal, self).seek_monotonic(timestamp, bootid)
 
     def log_level(self, level):
         """Sets maximum log level by setting matches for PRIORITY."""
@@ -124,13 +146,28 @@ class Journal(_Journal):
         else:
             raise ValueError("Log level must be 0 <= level <= 7")
 
-    def this_boot(self):
-        """Add match for _BOOT_ID equal to current boot ID."""
-        self.add_match(_BOOT_ID=_id128.get_boot().hex)
+    def this_boot(self, bootid=None):
+        """Add match for _BOOT_ID equal to current boot ID or the specified boot ID.
+
+        bootid should be either a UUID or a 32 digit hex number.
+        """
+        if bootid is None:
+            bootid = _id128.get_boot().hex
+        else:
+            bootid = getattr(bootid, 'hex', bootid)
+        self.add_match(_BOOT_ID=bootid)
+
+    def this_machine(self, machineid=None):
+        """Add match for _MACHINE_ID equal to the ID of this machine.
+
+        bootid should be either a UUID or a 32 digit hex number.
+        """
+        if machineid is None:
+            machineid = _id128.get_machine().hex
+        else:
+            machineid = getattr(machineid, 'hex', machineid)
+        self.add_match(_MACHINE_ID=machineid)
 
-    def this_machine(self):
-        """Add match for _MACHINE_ID equal to the ID of this machine."""
-        self.add_match(_MACHINE_ID=_id128.get_machine().hex)
 
 def _make_line(field, value):
         if isinstance(value, bytes):