dictdumper 0.8.4.post3__pp38-none-any.whl

dictdumper/__init__.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+"""Stream formatted output dumper.
+
+:mod:`dictdumper` is an open source Python program works as a
+stream formatted output dumper. Currently, it supports
+following formats:
+
+- :class:`~dictdumper.dumper.Dumper`
+
+  Abstract base class of all dumpers.
+
+- :class:`~dictdumper.json.JSON`
+
+  Dump JavaScript object notation (``JSON``) format file.
+
+- :class:`~dictdumper.plist.PLIST`
+
+  Dump Apple property list (``PLIST``) format file.
+
+- :class:`~dictdumper.tree.Tree`
+
+  Dump tree-view text (``TXT``) format file.
+
+- :class:`~dictdumper.xml.XML`
+
+  Dump extensible markup language (``XML``) file;
+  this is an abstract base class
+
+- :class:`~dictdumper.vuejs.VueJS`
+
+  Dump JavaScript file using ``Vue.js`` framework;
+  this class is deprecated due to grammar error.
+
+  .. deprecated:: 0.8.0
+
+"""
+# Base Class for DictDumper
+from dictdumper.dumper import Dumper  # pylint: disable=unused-import
+from dictdumper.xml import XML  # pylint: disable=unused-import
+
+# Utility Classes
+from dictdumper.json import JSON
+from dictdumper.plist import PLIST
+from dictdumper.tree import Tree
+
+# Deprecated Classes
+from dictdumper.vuejs import VueJS  # pylint: disable=unused-import
+
+__all__ = ['JSON', 'PLIST', 'Tree']
+
+# version string
+__version__ = '0.8.4.post3'

dictdumper/_dateutil.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+"""Date & time processing utilities."""
+
+import datetime
+
+__all__ = ['isoformat']
+
+try:
+    from datetime import _format_time
+except ImportError:
+    def _format_time(hh, mm, ss, us, timespec='auto'):
+        specs = {
+            'hours': '{:02d}',
+            'minutes': '{:02d}:{:02d}',
+            'seconds': '{:02d}:{:02d}:{:02d}',
+            'milliseconds': '{:02d}:{:02d}:{:02d}.{:03d}',
+            'microseconds': '{:02d}:{:02d}:{:02d}.{:06d}'
+        }
+
+        if timespec == 'auto':
+            # Skip trailing microseconds when us==0.
+            timespec = 'microseconds' if us else 'seconds'
+        elif timespec == 'milliseconds':
+            us //= 1000
+        try:
+            fmt = specs[timespec]
+        except KeyError:
+            raise ValueError('Unknown timespec value')
+        else:
+            return fmt.format(hh, mm, ss, us)
+
+try:
+    from datetime import _format_offset
+except ImportError:
+    def _format_offset(off):
+        s = ''
+        if off is not None:
+            if off.days < 0:
+                sign = "-"
+                off = -off
+            else:
+                sign = "+"
+            hh, mm = divmod(off, datetime.timedelta(hours=1))
+            mm, ss = divmod(mm, datetime.timedelta(minutes=1))
+            s += "%s%02d:%02d" % (sign, hh, mm)
+            if ss or ss.microseconds:
+                s += ":%02d" % ss.seconds
+
+                if ss.microseconds:
+                    s += '.%06d' % ss.microseconds
+        return s
+
+
+def isoformat(date):
+    """Generate ISO format date string."""
+    if hasattr(date, 'isoformat'):
+        return date.isoformat()
+    if isinstance(date, datetime.date):
+        return "%04d-%02d-%02d" % (date.year, date.month, date.day)
+    if isinstance(date, datetime.time):
+        s = _format_time(date.hour, date.minute, date.second,
+                         date.microsecond, 'auto')
+        off = date.utcoffset()
+        tz = _format_offset(off)
+        if tz:
+            s += tz
+        return s
+    if isinstance(date, datetime.datetime):
+        s = ("%04d-%02d-%02d%c" % (date.year, date.month, date.day, 'T') +
+             _format_time(date.hour, date.minute, date.second,
+                          date.microsecond, 'auto'))
+
+        off = date.utcoffset()
+        tz = _format_offset(off)
+        if tz:
+            s += tz
+
+        return s
+    raise NotImplementedError('unknown date object: %s' % date)

dictdumper/_hexlify.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+"""Binary data processing utilities."""
+
+import binascii
+
+
+def hexlify(s):
+    """Hexadecimal representation of binary data."""
+    if hasattr(s, 'hex'):
+        return s.hex()
+    return binascii.hexlify(s).decode()

dictdumper/_types.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+"""Types compatibility."""
+
+import sys
+
+if sys.version_info.major < 3:
+    bytes_type = str
+    str_type = unicode
+else:
+    bytes_type = bytes
+    str_type = str

dictdumper/dumper.py

@@ -0,0 +1,249 @@
+# -*- coding: utf-8 -*-
+"""base dumper
+
+:mod:`~dictdumper.dumper` contains :class:`~dictdumper.dumper.Dumper` only,
+which is an abstract base class for all dumpers, eg. :class:`~dictdumper.vuejs.VueJS`,
+:class:`~dictdumper.json.JSON`, :class:`~dictdumper.plist.PLIST`,
+:class:`~dictdumper.tree.Tree`, and :class:`~dictdumper.xml.XML`.
+
+"""
+# Abstract Base Class of Dumpers
+# Pre-define useful arguments and methods of dumpers
+
+import abc
+import collections
+import os
+import warnings
+
+from dictdumper._types import str_type
+
+__all__ = ['Dumper']
+
+
+def deprecated(cls):
+    """Deprecation warning.
+
+    Args:
+        cls (object): the class to mark as deprecated
+
+    Returns:
+        object: The original ``cls`` itself.
+
+    """
+    warnings.warn('%s is deprecated' % cls.__name__, DeprecationWarning, stacklevel=2)
+    return cls
+
+
+class DumperError(TypeError):
+    """Unsupported content type."""
+
+
+class Dumper(object):  # pylint: disable=metaclass-assignment,useless-object-inheritance
+    """Abstract base class of all dumpers.
+
+    .. code:: python
+
+        >>> dumper = Dumper(file_name)
+        >>> dumper(content_dict_1, name=content_name_1)
+        >>> dumper(content_dict_2, name=content_name_2)
+        ............
+
+    Attributes:
+        _file (str): output file name
+        _sptr (int): indicates start of appending point (file pointer)
+        _tctr (int): tab level counter
+        _hsrt (str): start string (``_HEADER_START``)
+        _hend (str): end string (``_HEADER_END``)
+
+    """
+    __metaclass__ = abc.ABCMeta
+
+    ##########################################################################
+    # Properties.
+    ##########################################################################
+
+    # file format of current dumper
+    @property
+    @abc.abstractmethod
+    def kind(self):
+        """File format of current dumper.
+
+        :rtype: str
+        """
+
+    @property
+    def filename(self):
+        """Output file name.
+
+        :rtype: str
+        """
+        return self._file
+
+    ##########################################################################
+    # Type codes.
+    ##########################################################################
+
+    #: Tuple[Tuple[type, str]]: Type codes.
+    __type__ = tuple()
+
+    ##########################################################################
+    # Methods.
+    ##########################################################################
+
+    @staticmethod
+    def make_object(o, value, **kwargs):
+        """Create an object with convertion information.
+
+        Args:
+            o (Any): object to convert
+            value (Any): converted value of ``o``
+            **kwargs: additional information for the convertion
+
+        Returns:
+            Dict[str, Any]: Information context of the convertion.
+
+        """
+        obj = collections.OrderedDict()
+        obj['type'] = str_type(type(o).__name__)
+        obj['value'] = value
+        for key, val in kwargs.items():
+            obj[key] = val
+        return obj
+
+    def object_hook(self, o):  # pylint: disable=unused-argument,no-self-use
+        """Convert content for function call.
+
+        Args:
+            o (Any): object to convert
+
+        Returns:
+            Any: the converted object
+
+        """
+        return o
+
+    def default(self, o):  # pylint: disable=unused-argument,no-self-use
+        """Check content type for function call.
+
+        Args:
+            o (Any): object to check
+
+        Raises:
+            DumperError: ``o`` is an unsupported content type
+
+        """
+        raise DumperError('unsupported content type: %s' % type(o).__name__)
+
+    ##########################################################################
+    # Attributes.
+    ##########################################################################
+
+    #: :obj:`int`, file pointer: Indicates start of appending point.
+    _sptr = os.SEEK_SET    # seek pointer
+    #: :obj:`int`: Tab level counter.
+    _tctr = 1              # counter for tab level
+
+    #: Dumper head string.
+    _hsrt = ''
+    #: Dumper tail string.
+    _hend = ''
+
+    ##########################################################################
+    # Data models.
+    ##########################################################################
+
+    def __new__(cls, fname, **kwargs):  # pylint: disable=unused-argument
+        self = super(Dumper, cls).__new__(cls)
+        return self
+
+    def __init__(self, fname, **kwargs):  # pylint: disable=unused-argument
+        """Initialise dumper.
+
+        Args:
+            fname (str): output file name
+            **kwargs: addition keyword arguments for initialisation
+
+        """
+        self._file = fname           # dump file name
+        self._dump_header(**kwargs)  # initialise output file
+
+    def __call__(self, value, name=None):
+        """Dumper a new block.
+
+        Args:
+            value (Dict[str, Any]): content to be dumped
+            name (v): name of current content block
+
+        Returns:
+            Dumper: the dumper class itself (to support chain calling)
+
+        """
+        with open(self._file, 'r+') as file:
+            self._append_value(value, file, name)
+            self._sptr = file.tell()
+            file.write(self._hend)
+        return self
+
+    ##########################################################################
+    # Utilities.
+    ##########################################################################
+
+    def _dump_header(self, **kwargs):  # pylint: disable=unused-argument
+        """Initially dump file heads and tails.
+
+        Keyword Args:
+            **kwargs: Arbitrary keyword arguments.
+
+        """
+        with open(self._file, 'w') as file:
+            file.write(self._hsrt)
+            self._sptr = file.tell()
+            file.write(self._hend)
+
+    def _encode_func(self, o):
+        """Check content type for function call.
+
+        Args:
+            o (Any): object to check
+
+        See Also:
+            If the type of ``o`` is not defined in :attr:`~Dumper.__type__`,
+            the function refers to :meth:`~Dumper.default` for custom hooks.
+
+        """
+        name = None
+        for (kind, code) in self.__type__:
+            if isinstance(o, kind):
+                name = code
+                break
+        if name is None:
+            name = self.default(o)  # pylint: disable=assignment-from-no-return
+
+        func = '_append_%s' % name
+        return getattr(self, func)
+
+    def _encode_value(self, o):
+        """Convert content for function call.
+
+        Args:
+            o (Any): object to convert
+
+        Returns:
+            Any: the converted object
+
+        See Also:
+            The function is a direct wrapper for :meth:`~Dumper.object_hook`.
+
+        """
+        return self.object_hook(o)
+
+    @abc.abstractmethod
+    def _append_value(self, value, file, name):
+        """Call this function to write contents.
+
+        Args:
+            value (Dict[str, Any]): content to be dumped
+            file (io.TextIOWrapper): output file
+            name (str): name of current content block
+
+        """