vhatable 1.2.1__py3-none-any.whl

vhatable/corev2.py

@@ -0,0 +1,294 @@
+#! /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 2023 Frédéric MARTIN
+#
+# Contributors list :
+#
+#  Frédéric MARTIN frederic.martin.fma@gmail.com
+#
+
+import logging
+import time
+from collections import OrderedDict
+from functools import wraps
+
+
+class Time:
+    """TODO"""
+
+    # pylint: disable=too-few-public-methods
+
+    def __init__(self, logger_name, label="execution time: {time:.15f}"):
+        self.log = logging.getLogger(logger_name)
+        self.enabled = False
+        self.label = label
+
+    def __call__(self, original_func):
+        @wraps(original_func)
+        def time_wrapper(*args, **kwargs):
+            self.log.debug("args: %s", args)
+            self.log.debug("kwargs: %s", kwargs)
+            start = time.time()
+            res = original_func(*args, **kwargs)
+            end = time.time()
+            if len(args) > 0:
+                first_arg = args[0]
+                self.enabled = getattr(first_arg, "verbose", self.enabled)
+            diff = end - start
+            msg = self.label.format(time=diff)
+            self.log.debug(msg)
+            if self.enabled:
+                print(msg)
+            return res
+
+        return time_wrapper
+
+
+class AutoTime:
+    """TODO"""
+
+    # pylint: disable=too-few-public-methods
+
+    def __init__(self, label="execution time: {time:.15f}"):
+        self.enabled = False
+        self.label = label
+
+    def __call__(self, original_func):
+        @wraps(original_func)
+        def time_wrapper(*args, **kwargs):
+            logger_name = args[0].__class__.__name__
+            logger_name += "." + original_func.__name__
+            log = logging.getLogger(logger_name)
+            log.debug("args: %s", args)
+            log.debug("kwargs: %s", kwargs)
+            start = time.time()
+            res = original_func(*args, **kwargs)
+            end = time.time()
+            if len(args) > 0:
+                first_arg = args[0]
+                self.enabled = getattr(first_arg, "verbose", self.enabled)
+            diff = end - start
+            msg = self.label.format(time=diff)
+            log.debug(msg)
+            if self.enabled:
+                print(msg)
+            return res
+
+        return time_wrapper
+
+
+class Unit:
+    """TODO"""
+
+    def __init__(self, typ="transform", debug=0, identifier=None):
+        self.log = logging.getLogger(__name__)
+        self._debug = debug
+        self._verbose = False
+        self.identifier = identifier
+        self._attrs = []
+        self._gattrs = ["debug", "verbose"]
+        self._attrs_ro = []
+        self.typ = typ
+
+    @property
+    def debug(self):
+        """TODO"""
+        return self._debug
+
+    @debug.setter
+    def debug(self, debug):
+        """TODO"""
+        self._debug = debug
+
+    @property
+    def verbose(self):
+        """TODO"""
+        return self._verbose
+
+    @verbose.setter
+    def verbose(self, verbose):
+        """TODO"""
+        self._verbose = verbose
+
+    def setup(self, from_args):
+        """TODO"""
+        for attr in self._gattrs:
+            if hasattr(from_args, attr):
+                setattr(self, attr, getattr(from_args, attr))
+            self.log.debug("setup:gattr: %s : %s", attr, getattr(self, attr))
+        for attr in self._attrs:
+            if self.identifier:
+                attr_with_prefix = self.identifier + "_" + attr
+                if hasattr(from_args, attr_with_prefix):
+                    setattr(self, attr, getattr(from_args, attr_with_prefix))
+            else:
+                if hasattr(from_args, attr):
+                    setattr(self, attr, getattr(from_args, attr))
+            self.log.debug("setup:attr: %s : %s", attr, getattr(self, attr))
+        return self
+
+    def __str__(self):
+        rows = []
+        prefix = ""
+        if self.identifier:
+            prefix = self.identifier + "_"
+
+        rows.append("Unit: " + self.__class__.__name__ + ":")
+        for attr in self._gattrs:
+            attr_val = getattr(self, attr)
+            rows.append(f" - global: {attr}: {attr_val}")
+        for attr in self._attrs:
+            attr_val = getattr(self, attr)
+            rows.append(f" - {prefix}{attr}: {attr_val}")
+        for attr in self._attrs_ro:
+            attr_val = getattr(self, attr)
+            rows.append(f" - readonly: {prefix}{attr}: {attr_val}")
+        rows.append("")
+        return "\n".join(rows)
+
+    def __call__(self, rows):
+        raise NotImplementedError()
+
+
+class AbstractProcessor:
+    """TODO"""
+
+    # pylint: disable=too-many-instance-attributes
+
+    def __init__(
+        self,
+        debug=0,
+        verbose=False,
+        rows=None,
+        column_names=None,
+        autokeys=True,
+        messages=None,
+        identifier=None,
+    ):
+        # pylint: disable=too-many-arguments
+        self._attrs = ["debug", "verbose", "column_names"]
+        self._attrs_ro = ["identifier", "messages"]
+        classname = str(self.__class__.__name__.lower())
+        self.log = logging.getLogger("vhatable." + classname)
+        self.identifier = identifier
+        self.units = OrderedDict()
+        self.column_names = []
+        self._rows = []
+        self._raw_cache = None
+        self._post_init = False
+        self.messages = {}
+        self.messages[self.identifier] = {}
+        self.debug = debug
+        self.verbose = verbose
+        if rows:
+            self._rows = rows
+        if column_names:
+            self.column_names = column_names
+        elif autokeys and rows and len(rows) >= 1:
+            self.column_names = rows[0].keys()
+        self._update_messages(messages)
+
+    def _update_messages(self, messages):
+        if messages and self.identifier in messages:
+            messages = messages[self.identifier]
+            self.messages[self.identifier].update(messages)
+
+    def _format_messages(self, key, data):
+        return self.messages[self.identifier][key].format(**data)
+
+    def add_unit(self, unit):
+        """TODO"""
+        self.units[unit.identifier] = unit
+
+    def post_init(self):
+        """TODO"""
+        self._post_init = True
+
+    def __getattr__(self, attr):
+        if attr in self.units:
+            return self.units[attr]
+        classname = self.__class__.__name__
+        raise AttributeError(f"'{classname}' object has no attribute '{attr}'")
+
+    def __str__(self):
+        rows = []
+        rows.append("Processor - " + self.__class__.__name__ + ":")
+        for attr in self._attrs:
+            attr_val = getattr(self, attr)
+            rows.append(f" - {attr}: {attr_val}")
+        for attr in self._attrs_ro:
+            attr_val = getattr(self, attr)
+            rows.append(f" - readonly: {attr}: {attr_val}")
+        rows.append("")
+        for unit in self.units.values():
+            rows.append(str(unit))
+        return "\n".join(rows)
+
+    def pre_get_raw_hook(self):
+        """When get_raw method is called, this method is called just before
+        doing anything. It could be use full to run some extra configuration
+        steps.
+        """
+
+    def get_raw(self):
+        """TODO"""
+        if self._raw_cache is not None:
+            if self.debug >= 2:
+                self.log.debug("cached rows: %s", self._raw_cache)
+            return self._raw_cache
+        if not self._post_init:
+            raise ValueError("post_init method was not called.")
+        self.log.debug("Units: %s", self.units)
+        self.log.debug("Rows: %s", self._rows)
+        self.pre_get_raw_hook()
+        pipeline = self._rows
+        for unit in self.units.values():
+            if unit.typ == "transform":
+                self.log.debug("unit:transform: %s", unit)
+                self.log.debug("unit:transform:begin: %s", unit.__class__.__name__)
+                pipeline = unit(pipeline)
+                self.log.debug("unit:transform:end  : %s", unit.__class__.__name__)
+        self._raw_cache = list(pipeline)
+        if self.debug >= 2:
+            self.log.debug("pipeline rows: %s", self._raw_cache)
+        return self._raw_cache
+
+    def load(self, rows):
+        """TODO"""
+        self._rows = rows
+        return self
+
+    def setup(self, from_args):
+        """TODO"""
+        self.post_init()
+        for attr in self._attrs:
+            if hasattr(from_args, attr):
+                setattr(self, attr, getattr(from_args, attr))
+            self.log.debug("setup:attr: %s : %s", attr, getattr(self, attr))
+        for unit in self.units.values():
+            unit.setup(from_args)
+        return self
+
+    @Time("vhatable.corev2.run")
+    def run(self):
+        """TODO"""
+        for row in self.get_raw():
+            print(row)
+        return True

vhatable/demo.py

@@ -0,0 +1,368 @@
+"""TODO"""
+
+import argparse
+import json
+import logging
+import os
+import sys
+
+import requests
+
+from vhatable.cellv2 import ComplexCellBuilder
+from vhatable.filters import PartialOr
+from vhatable.filtersv2 import EqualMultipleOr, PartialMultipleAnd
+from vhatable.processors import API, ProcessorBuilder, ProcessorFactory, UpdateProcessor
+from vhatable.units import UpdateRowsUnit
+
+
+class DemoAPI(API):
+    """TODO"""
+
+    URL = "https://epguides.frecar.no/show/bigbangtheory/"
+    CACHEFILENAME = "/tmp/vhatable-demo--cache-big-bang.json"
+
+    def __init__(self):
+        super().__init__()
+        self.data = self._load_json()
+
+    def _persist(self, data):
+        # pylint: disable=unspecified-encoding
+        with open(self.CACHEFILENAME, "w") as json_file:
+            json.dump(data, json_file)
+
+    def reset(self):
+        """remove cache file to reset the current state"""
+        os.remove(self.CACHEFILENAME)
+
+    def _load_json(self):
+        """TODO"""
+        # pylint: disable=unspecified-encoding
+        data = None
+        if os.path.isfile(self.CACHEFILENAME):
+            with open(self.CACHEFILENAME) as user_file:
+                file_contents = user_file.read()
+                data = json.loads(file_contents)
+            return data
+
+        data = requests.get(self.URL, timeout=60).json()
+        res = {}
+        cpt = 0
+        for season in data:
+            for episode in data[season]:
+                cpt += 1
+                episode["ID"] = cpt
+                episode["notes"] = "TODO"
+                res[cpt] = episode
+        self._persist(res)
+        return res
+
+    def list(self):
+        """TODO"""
+        return self.data.values()
+
+    def column_names(self):
+        """TODO"""
+        return ["ID", "season", "number", "title", "release_date", "show", "notes"]
+
+    def delete(self, row):
+        """TODO"""
+        row_id = str(row["ID"])
+        row = self.data.pop(row_id)
+        self._persist(self.data)
+        return True, row
+
+    def get(self, row_id):
+        row_id = str(row_id)
+        row = self.data.get(row_id)
+        if row is None:
+            raise ValueError("row id not found " + row_id)
+        return row
+
+    def update(self, row):
+        row_id = str(row["ID"])
+        old_row = self.data.get(row_id)
+        if old_row is None:
+            raise ValueError("row id not found " + row_id)
+        if old_row != row:
+            self.data[row_id] = row
+            self._persist(self.data)
+        return True, row
+
+
+api = DemoAPI()
+
+
+def newfactory():
+    """TODO"""
+    messages = {}
+    messages["delete"] = {
+        "nothing_to_do": "Nothing to delete.",
+        "done": (
+            "{prefix}{_position}/{_count}: The episode '{title}' ({ID}) was deleted. ({_time}s)"
+        ),
+        "done_failure": (
+            "{prefix}{_position}/{_count}: Failure "
+            "The episode '{title}' ({ID}) was not deleted. ({_time}s)"
+        ),
+    }
+    messages["update"] = {
+        "nothing_to_do": "Nothing to update.",
+        "done": (
+            "{prefix}{_position}/{_count}: The episode '{title}' ({ID}) was updated. ({_time}s)"
+        ),
+        "done_failure": (
+            "{prefix}{_position}/{_count}: Failure "
+            "The episode '{title}' ({ID}) was not updated. ({_time}s)"
+        ),
+    }
+    messages["count"] = {"count_elt": "Episodes found: {count}"}
+    factory = ProcessorFactory()
+    factory.set_default_processor_builder(
+        ProcessorBuilder(api=api, autoload=True, messages=messages)
+    )
+    factory.add_processor(
+        "update",
+        UpdateProcessor,
+        builder=ProcessorBuilder(
+            api=api,
+            autoload=True,
+            # we override default updatable columns,
+            # only notes is updatable
+            units=[UpdateRowsUnit(["notes"])],
+            messages=messages,
+        ),
+    )
+    factory.add_custom_cell(
+        ComplexCellBuilder(
+            "show", fmt="{title} {imdb_id} {epguide_name}", fmtv="{title} {imdb_id} {epguide_name}"
+        )
+    )
+    factory.set_align_cell("title", "l")
+    factory.set_align_cell("show", "c")
+    factory.set_header_cell("number", "episode")
+    return factory
+
+
+def add_list_cmd_options(parser):
+    """Add all default option to the current parser."""
+    parser.add_argument(
+        "--count",
+        default=False,
+        action="store_true",
+        help="Count the number of the displayed rows",
+        dest="count",
+    )
+    parser.add_argument(
+        "--vertical",
+        default=False,
+        action="store_true",
+        help="Use vertical display",
+        dest="vertical",
+    )
+    parser.add_argument(
+        "--json", default=False, action="store_true", help="Display rows as json", dest="json"
+    )
+    parser.add_argument(
+        "--json-raw", default=False, action="store_true", help="Display raw json", dest="json_raw"
+    )
+    parser.add_argument(
+        "--csv", default=False, action="store_true", help="Display rows as csv", dest="csv"
+    )
+    parser.add_argument(
+        "--start", default=0, type=int, help="Only display the N first rows", dest="slice_start"
+    )
+    parser.add_argument(
+        "--end", default=0, type=int, help="Only display the N last rows", dest="slice_end"
+    )
+    parser.add_argument(
+        "--limit",
+        default=0,
+        type=int,
+        help="limit the number of rows to display",
+        dest="slice_limit",
+    )
+    parser.add_argument("--sort-by", help="sort row by column", dest="sort_sort_by")
+    parser.add_argument(
+        "--sort-reversed",
+        help="Reverse order while sorting",
+        default=False,
+        action="store_true",
+        dest="sort_reverse",
+    )
+
+
+def add_list_command(main_subparsers):
+    """TODO"""
+
+    def command(args):
+        """This command will remove an episode from the cache."""
+        factory = newfactory()
+        factory.add_filters(PartialMultipleAnd("title", args.titles))
+        factory.add_filters(PartialOr("release_date", args.release_dates))
+        factory.add_filters(PartialOr("season", args.seasons))
+        factory.add_filters(PartialOr("number", args.episodes))
+        factory.add_filters(EqualMultipleOr("ID", args.ids))
+        processor = factory.create(args)
+        print(processor)
+        processor.run()
+        print()
+
+    parser = main_subparsers.add_parser("list")
+    parser.set_defaults(func=command)
+    add_list_cmd_options(parser)
+
+    parser.add_argument("titles", nargs="*", help="Filter by title")
+
+    parser.add_argument(
+        "--release-date", action="append", help="Filter by release date", dest="release_dates"
+    )
+
+    parser.add_argument("--season", action="append", help="Filter by season", dest="seasons")
+
+    parser.add_argument("--id", action="append", type=int, help="Filter by id", dest="ids")
+
+    parser.add_argument("--episode", action="append", help="Filter by episode", dest="episodes")
+
+    parser.add_argument(
+        "--delete", default=False, action="store_true", help="Delete selected rows", dest="delete"
+    )
+
+    parser.add_argument(
+        "--update", default=False, action="store_true", help="update selected rows", dest="update"
+    )
+
+    parser.add_argument(
+        "--notes", default=None, action="store", help="update notes column", dest="update_notes"
+    )
+    parser.add_argument(
+        "--update-title",
+        default=None,
+        action="store",
+        help="update title column",
+        dest="update_title",
+    )
+
+
+def add_delete_command(main_subparsers):
+    """TODO"""
+
+    def command(args):
+        """This command will remove some episode from the list.
+        This implementation is not the best since we load the entire of
+        episodes and we filter them.
+        Another solution: We can use the list of IDs to retrieve episode one by
+        one and then build a list of them. No more filtering.
+        A more performant implementation.
+        """
+        factory = newfactory()
+        factory.default_processor_identifier = "delete"
+        factory.add_filters(EqualMultipleOr("ID", args.ids))
+        processor = factory.create(args)
+        print(processor)
+        processor.run()
+        print()
+
+    parser = main_subparsers.add_parser("delete")
+    parser.set_defaults(func=command)
+    parser.add_argument("ids", nargs="+", type=int, help="Delete episode by id")
+
+
+def add_delete_commandv2(main_subparsers):
+    """TODO"""
+
+    def command(args):
+        """This command will remove some episode from the list.
+        We retrieve episode one by one and then build a list
+        of them. No more filtering.
+        A more performant implementation.
+        """
+        rows = []
+        for row_id in args.ids:
+            rows.append(api.get(row_id))
+
+        factory = newfactory()
+        factory.default_processor_identifier = "delete"
+        processor = factory.create(args)
+        processor.load(rows)
+        print(processor)
+        processor.run()
+        print()
+
+    parser = main_subparsers.add_parser("deletev2")
+    parser.set_defaults(func=command)
+    parser.add_argument("ids", nargs="+", type=int, help="Delete episode by id")
+
+
+def add_reset_command(main_subparsers):
+    """TODO"""
+
+    def command(args):
+        """Reset the local cache"""
+        # pylint: disable=unused-argument
+        api.reset()
+
+    parser = main_subparsers.add_parser("reset")
+    parser.set_defaults(func=command)
+
+
+def add_update_command(main_subparsers):
+    """TODO"""
+
+    def command(args):
+        """This command will remove some episode from the list.
+        We retrieve episode one by one and then build a list
+        of them. No more filtering.
+        A more performant implementation.
+        """
+        rows = []
+        for row_id in args.ids:
+            rows.append(api.get(row_id))
+
+        factory = newfactory()
+        factory.default_processor_identifier = "update"
+        processor = factory.create(args)
+        processor.load(rows)
+        print(processor)
+        processor.run()
+        print()
+
+    parser = main_subparsers.add_parser("update")
+    parser.set_defaults(func=command)
+    parser.add_argument("ids", nargs="+", type=int, help="Update episode by id")
+    parser.add_argument(
+        "--notes", default=None, action="store", help="update notes column", dest="update_notes"
+    )
+    parser.add_argument(
+        "--title", default=None, action="store", help="update title column", dest="update_title"
+    )
+
+
+def main():
+    """Main entrypoint of this sample program."""
+    log = logging.getLogger()
+    log.setLevel(logging.INFO)
+    stdout = logging.StreamHandler(sys.stdout)
+    fmt = "%(asctime)s:%(name)s:%(funcName)s:%(levelname)s:%(message)s"
+    formatter = logging.Formatter(fmt)
+    stdout.setFormatter(formatter)
+    log.addHandler(stdout)
+
+    main_parser = argparse.ArgumentParser(description="Demo cli")
+    main_parser.add_argument("-d", "--debug", type=int, default=0, help="debug level", dest="debug")
+    main_subparsers = main_parser.add_subparsers()
+
+    add_list_command(main_subparsers)
+    add_delete_command(main_subparsers)
+    add_delete_commandv2(main_subparsers)
+    add_reset_command(main_subparsers)
+    add_update_command(main_subparsers)
+
+    args = main_parser.parse_args()
+    if args.debug >= 1:
+        log.setLevel(logging.DEBUG)
+    if "func" in args:
+        print("Demo: ", args.func.__doc__ + "\n")
+        sys.exit(args.func(args))
+    else:
+        print("ERROR: Missing command. see -h")
+        sys.exit(2)