vhatable 1.2.1__py3-none-any.whl

vhatable/__init__.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+"""TODO"""
+
+
+# This file is part of Vhatable api.
+#
+# Vhatable api is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Vhatable api is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Vhatable api.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Copyright 2014-2016 Frédéric MARTIN
+#
+# Contributors list :
+#
+#  Frédéric MARTIN frederic.martin.fma@gmail.com
+#
+
+__all__ = ["cell", "core", "filters"]

vhatable/cell.py

@@ -0,0 +1,344 @@
+#! /usr/bin/env python
+"""TODO"""
+
+
+# This file is part of Vhatable cli.
+#
+# Vhatable cli is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Vhatable cli is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Vhatable cli.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Copyright 2019 Frédéric MARTIN
+#
+# Contributors list :
+#
+#  Frédéric MARTIN frederic.martin.fma@gmail.com
+#
+
+import datetime
+import logging
+
+from humanfriendly import format_size
+
+
+class CellFactory:
+    """TODO"""
+
+    # pylint: disable=too-few-public-methods
+    # pylint: disable=too-many-instance-attributes
+
+    def __init__(self, raw=False, vertical=False, debug=0):
+        self.raw = raw
+        self.debug = debug
+        self.vertical = vertical
+        classname = str(self.__class__.__name__.lower())
+        self.log = logging.getLogger("vhatablecli.cell." + classname)
+        self.date_cells = ["creationDate", "modificationDate", "expirationDate", "uploadDate"]
+        self.size_cells = ["size"]
+        self.custom_cells = {}
+
+    def __call__(self, name, value, row=None):
+        if name in self.custom_cells:
+            clazz = self.custom_cells.get(name)
+        elif name in self.date_cells:
+            clazz = DateCell
+        elif name in self.size_cells:
+            clazz = SizeCell
+        elif isinstance(value, bool):
+            clazz = BCell
+        elif isinstance(value, int):
+            clazz = ICell
+        elif isinstance(value, (list, dict)):
+            clazz = ComplexCell
+        else:
+            clazz = SCell
+        if self.debug >= 2:
+            self.log.debug("building cell ...")
+            self.log.debug("property: %s", name)
+            self.log.debug("value type: %s", type(value))
+            self.log.debug("value: %s", value)
+            self.log.debug("raw: %s", self.raw)
+            self.log.debug("vertical: %s", self.vertical)
+        cell = clazz(value)
+        cell.name = name
+        cell.raw = self.raw
+        cell.vertical = self.vertical
+        if row is not None:
+            cell.row = row
+        if self.debug >= 3:
+            self.log.debug("cell type: %s", type(cell))
+            # str method from all cell must return encoded strings
+            self.log.debug("cell rendering: %s", str(cell))
+            self.log.debug("cell built.")
+        return cell
+
+
+class BaseCell:
+    """TODO"""
+
+    value = None
+    raw = False
+    row = {}
+    vertical = False
+    extended = False
+    hidden = False
+    name = None
+    _format = None
+    _format_vertical = None
+    _format_filter = None
+    none = "-"
+
+    def __init__(self, value):
+        self.value = value
+
+    @property
+    def formatt(self):
+        """TODO"""
+        return self._format
+
+    @formatt.setter
+    def formatt(self, formatt):
+        """TODO"""
+        self._format = formatt
+
+    @property
+    def formatv(self):
+        """TODO"""
+        return self._format_vertical
+
+    @formatv.setter
+    def formatv(self, formatv):
+        """TODO"""
+        self._format_vertical = formatv
+
+    @property
+    def formatf(self):
+        """TODO"""
+        return self._format_filter
+
+    @formatf.setter
+    def formatf(self, formatf):
+        """TODO"""
+        self._format_filter = formatf
+
+    def match(self, regex):
+        """Apply the input regext to the current object"""
+        if self._format_filter and regex.match(self._format_filter.format(**self.value)):
+            return True
+        return bool(regex.match(str(self)))
+
+    def __unicode__(self):
+        """TODO"""
+        if self.raw:
+            return str(self.value)
+        return str(self.value)
+
+    def __str__(self):
+        """TODO"""
+        return self.__unicode__()
+
+    def __eq__(self, item):
+        return self.value == item
+
+    def __lt__(self, value):
+        if value is None:
+            return True
+        if self.value is None:
+            return True
+        return self.value < value
+
+    def __le__(self, value):
+        if value is None:
+            return True
+        if self.value is None:
+            return True
+        return self.value <= value
+
+    def __gt__(self, value):
+        if value is None:
+            return False
+        if self.value is None:
+            return False
+        return self.value > value
+
+    def __ge__(self, value):
+        if value is None:
+            return False
+        if self.value is None:
+            return False
+        return self.value >= value
+
+
+class SCell(BaseCell):
+    """This class is used to emulate str type for veryprettytable.
+    VeryPrettyTable will call the __str__ method on non-unicode objects.
+    It requires that the __str__ output is utf-8 encoded."""
+
+    # pylint: disable=too-few-public-methods
+    # pylint: disable=too-many-instance-attributes
+
+    def __unicode__(self):
+        """TODO"""
+        if self.raw:
+            if self.value is None:
+                return "None"
+            return str(self.value)
+        if self.value is None:
+            return self.none
+        if self.vertical and self._format_vertical:
+            return self._format_vertical.format(value=self.value)
+        if self._format:
+            return self._format.format(value=self.value)
+        return str(self.value)
+
+    def __add__(self, item):
+        return self.value + item
+
+    def lower(self):
+        """return a lower case version of the current value"""
+        return self.value.lower()
+
+
+class DateCell(BaseCell):
+    """TODO"""
+
+    millisecond = True
+
+    # pylint: disable=too-few-public-methods
+    def __init__(self, value):
+        super().__init__(value)
+        fmt = "{da:%Y-%m-%d %H:%M:%S}"
+        self._format = fmt
+        self._format_vertical = fmt
+        # self._format_filter = fmt
+
+    def __unicode__(self):
+        if self.raw:
+            return str(self.value)
+        if self.value is not None:
+            fmt = self._format
+            if self.vertical:
+                fmt = self._format_vertical
+            div = 1
+            if self.millisecond:
+                div = 1000
+            return fmt.format(da=datetime.datetime.fromtimestamp(self.value / div))
+        return self.none
+
+    def __div__(self, value):
+        return self.value / value
+
+
+class ICell(int, BaseCell):
+    """TODO"""
+
+    # pylint: disable=too-few-public-methods
+
+    def __init__(self, value):
+        super().__init__(value)
+        self.value = value
+
+    def __unicode__(self):
+        if self.raw:
+            return str(self.value)
+        return str(self.value)
+
+
+class BCell(BaseCell):
+    """TODO"""
+
+    # pylint: disable=too-few-public-methods
+
+    def __unicode__(self):
+        if self.raw:
+            return str(self.value)
+        return str(self.value)
+
+
+class SizeCell(BaseCell):
+    """TODO"""
+
+    # pylint: disable=too-few-public-methods
+
+    def __div__(self, value):
+        return self.value / value
+
+    def __unicode__(self):
+        if self.raw:
+            return str(self.value)
+        if self.value is None:
+            return self.none
+        return format_size(self.value)
+
+
+class TypeCell(BaseCell):
+    """TODO"""
+
+    def __str__(self):
+        return str(type(self.value))
+
+
+class ComplexCell(BaseCell):
+    """TODO"""
+
+    # pylint: disable=too-few-public-methods
+    # pylint: disable=too-many-instance-attributes
+
+    def __unicode__(self):
+        if self.raw:
+            return str(self.value)
+        if self.value is None:
+            return self.none
+        if self.vertical and self._format_vertical:
+            return self._format_vertical.format(**self.value)
+        if self._format:
+            return self._format.format(**self.value)
+        return str(self.value)
+
+    def keys(self):
+        """TODO"""
+        return list(self.value.keys())
+
+    def __getitem__(self, key):
+        return self.value[key]
+
+
+class CellBuilder:
+    """wrapper to build a Cell with extra parameters."""
+
+    # pylint: disable=too-few-public-methods
+
+    def __init__(self, formatt, formatv=None, formatf=None, cell=SCell):
+        self._format = formatt
+        self._formatv = formatt
+        self._formatf = None
+        if formatv:
+            self._formatv = formatv
+        if formatf:
+            self._formatf = formatf
+        self.clazz = cell
+
+    def __call__(self, value):
+        cell = self.clazz(value)
+        cell.formatt = self._format
+        cell.formatv = self._formatv
+        cell.formatf = self._formatf
+        return cell
+
+
+class ComplexCellBuilder(CellBuilder):
+    """wrapper to build a ComplexCell with extra parameters."""
+
+    # pylint: disable=too-few-public-methods
+
+    def __init__(self, formatt, formatv=None, formatf=None):
+        super().__init__(formatt, formatv, formatf, cell=ComplexCell)

vhatable/cellv2.py

@@ -0,0 +1,227 @@
+#! /usr/bin/env python
+"""Contains cell builders and factory to handle rendering in a table."""
+
+
+# This file is part of Vhatable cli.
+#
+# Vhatable cli is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Vhatable cli is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Vhatable cli.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Copyright 2019 Frédéric MARTIN
+#
+# Contributors list :
+#
+#  Frédéric MARTIN frederic.martin.fma@gmail.com
+#
+
+import logging
+
+from .cell import BCell, ComplexCell, DateCell, ICell, SCell, SizeCell, TypeCell
+
+
+class CellBuilder:
+    """A helper to configure and build a cell."""
+
+    # pylint: disable=too-few-public-methods
+    # pylint: disable=[too-many-arguments]
+
+    clazz = None
+
+    def __init__(self, cell_name, fmt=None, fmtv=None, fmtf=None, none="-", clazz=None):
+        """Create a builder:
+
+        :param str cell_name: coucou
+        :param str none: giggiggigi
+        """
+        self.none = none
+        self.cell_name = cell_name
+        if clazz is not None:
+            self.clazz = clazz
+        self.fmt = fmt
+        self.fmt_vertical = fmtv
+        self.fmt_for_filtering = fmtf
+
+    def __call__(
+        self,
+        cell_value,
+        raw_display=False,
+        vertical=False,
+        extended=False,
+        hidden=False,
+        context=None,
+    ):
+        """Build and return a new cell"""
+        cell = self.clazz(cell_value)
+        cell.name = self.cell_name
+        if self.fmt is not None:
+            cell.formatt = self.fmt
+        if self.fmt_vertical is not None:
+            cell.formatv = self.fmt_vertical
+        if self.fmt_for_filtering is not None:
+            cell.formatf = self.fmt_for_filtering
+        cell.raw = raw_display
+        cell.vertical = vertical
+        cell.extended = extended
+        cell.hidden = hidden
+        if context is not None:
+            cell.row = context
+        return self._post_build(cell)
+
+    def _post_build(self, cell):
+        """Hook use to enhance cell with extra property once created."""
+        # pylint: disable=no-self-use
+        return cell
+
+
+class StringCellBuilder(CellBuilder):
+    """Builder for a StringCell (SCell)"""
+
+    # pylint: disable=too-few-public-methods
+
+    clazz = SCell
+
+
+class IntCellBuilder(CellBuilder):
+    """Builder for a ICell"""
+
+    # pylint: disable=too-few-public-methods
+
+    clazz = ICell
+
+
+class BoolCellBuilder(CellBuilder):
+    """Builder for a BCell"""
+
+    # pylint: disable=too-few-public-methods
+
+    clazz = BCell
+
+
+class DateCellBuilder(CellBuilder):
+    """Builder for a DateCell"""
+
+    # pylint: disable=too-few-public-methods
+
+    clazz = DateCell
+
+    def __init__(self, *args, millisecond=True, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.millisecond = millisecond
+
+    def _post_build(self, cell):
+        """TODO"""
+        cell.millisecond = self.millisecond
+        return cell
+
+
+class SizeCellBuilder(CellBuilder):
+    """Builder for a SizeCell"""
+
+    # pylint: disable=too-few-public-methods
+
+    clazz = SizeCell
+
+
+class TypeCellBuilder(CellBuilder):
+    """Builder for a TypeCell.
+    It will just render type of the content of the cell.
+    Could be used for debug."""
+
+    # pylint: disable=too-few-public-methods
+
+    clazz = TypeCell
+
+
+class ComplexCellBuilder(CellBuilder):
+    """Builder for a ComplexCell.
+    A complex cell is a json."""
+
+    # pylint: disable=too-few-public-methods
+
+    clazz = ComplexCell
+
+
+class CellBuilderFactory:
+    """TODO"""
+
+    # pylint: disable=too-few-public-methods
+    # pylint: disable=too-many-instance-attributes
+
+    def __init__(self):
+        self.raw_display = False
+        self.debug = 0
+        self.vertical = False
+        classname = str(self.__class__.__name__.lower())
+        self.log = logging.getLogger("vhatablecli.cellv2." + classname)
+        self.date_cells = ["creationDate", "modificationDate", "expirationDate", "uploadDate"]
+        self.size_cells = ["size"]
+        self.custom_cells = {}
+
+    def get_cell_builder(self, cell_name, cell_value):
+        """Return the cell builder accoring the configuration or type of
+        the input cell_value.
+        """
+        builder_clazz = None
+        if cell_name in self.date_cells:
+            builder_clazz = DateCellBuilder
+        elif cell_name in self.size_cells:
+            builder_clazz = SizeCellBuilder
+        elif isinstance(cell_value, bool):
+            builder_clazz = BoolCellBuilder
+        elif isinstance(cell_value, int):
+            builder_clazz = IntCellBuilder
+        elif isinstance(cell_value, (list, dict)):
+            builder_clazz = ComplexCellBuilder
+        else:
+            builder_clazz = StringCellBuilder
+        return builder_clazz(cell_name)
+
+    def __call__(
+        self,
+        cell_name,
+        cell_value,
+        context=None,
+        extended=False,
+        vertical=None,
+        hidden=False,
+        raw_display=None,
+    ):
+        if vertical is not None:
+            self.vertical = vertical
+        if raw_display is not None:
+            self.raw_display = raw_display
+        if cell_name in self.custom_cells:
+            builder = self.custom_cells.get(cell_name)
+        else:
+            builder = self.get_cell_builder(cell_name, cell_value)
+        if self.debug >= 2:
+            self.log.debug("building cell ...")
+            self.log.debug("builder: %s", builder)
+            self.log.debug("name: %s, type: %s", cell_name, type(cell_value))
+            self.log.debug("cell_value: %s", cell_value)
+            self.log.debug("raw_display: %s", self.raw_display)
+            self.log.debug("vertical: %s", self.vertical)
+        cell = builder(
+            cell_value,
+            raw_display=self.raw_display,
+            vertical=self.vertical,
+            extended=extended,
+            hidden=hidden,
+            context=context,
+        )
+        if self.debug >= 3:
+            self.log.debug("cell type: %s", type(cell))
+            # str method from all cell must return encoded strings
+            self.log.debug("cell rendering: %s", str(cell))
+            self.log.debug("cell built.")
+        return cell