Refactoring: simplify logging

requirements/requirements.txt

@@ -6,5 +6,5 @@ nbformat>=4.4.0
 path.py
 pytablereader>=0.20.0
 SimpleSQLite>=0.23.0
-sqliteschema>=0.9.7
+sqliteschema>=0.10.1
 typepy>=0.1.0

sqlitebiter/_common.py

@@ -4,33 +4,12 @@
 .. codeauthor:: Tsuyoshi Hombashi <tsuyoshi.hombashi@gmail.com>
 '''
 
-from __future__ import absolute_import
+from __future__ import absolute_import, unicode_literals
 
-from sqliteschema import SqliteSchemaExtractor
 
-from ._const import MAX_VERBOSITY_LEVEL
+def get_success_message(source, schema_extractor, table_name, verbosity_level):
+    table_schema = schema_extractor.fetch_table_schema(table_name.strip())
 
-
-def get_success_message(verbosity_level, source, dst_table_name):
-    message_template = u"convert '{:s}' to '{:s}' table"
-
-    return message_template.format(source, dst_table_name.strip())
-
-
-def get_schema_extractor(source, verbosity_level):
-    found_ptw = True
-    try:
-        import pytablewriter  # noqa: W0611
-    except ImportError:
-        found_ptw = False
-
-    if verbosity_level >= MAX_VERBOSITY_LEVEL and found_ptw:
-        return SqliteSchemaExtractor(source, verbosity_level=0, output_format="table")
-
-    if verbosity_level >= 1:
-        return SqliteSchemaExtractor(source, verbosity_level=3, output_format="text")
-
-    if verbosity_level == 0:
-        return SqliteSchemaExtractor(source, verbosity_level=0, output_format="text")
-
-    raise ValueError("invalid verbosity_level: {}".format(verbosity_level))
+    return "convert '{source:s}' to '{table_info:s}' table".format(
+        source=source,
+        table_info=table_schema.dumps(output_format="text", verbosity_level=verbosity_level))

sqlitebiter/_dict_converter.py

@@ -80,5 +80,5 @@ def __write(self, table_data):
         self.__result_counter.inc_success()
 
         self.__logger.info(get_success_message(
-            self.__verbosity_level, self.__source,
-            self.__schema_extractor.get_table_schema_text(sqlite_tabledata.table_name)))
+            self.__source, self.__schema_extractor, sqlite_tabledata.table_name,
+            self.__verbosity_level))

sqlitebiter/_table_creator.py

@@ -8,7 +8,7 @@
 from __future__ import absolute_import
 
 import simplesqlite
-from sqliteschema import SqliteSchemaExtractor
+from sqliteschema import SQLiteSchemaExtractor
 
 
 class TableCreator(object):
@@ -43,18 +43,10 @@ def __require_rename_table(self, src_con, src_table_name):
         if not self.__dst_con.has_table(src_table_name):
             return False
 
-        if (self.__dst_con.fetch_attr_name_list(src_table_name) !=
-                src_con.fetch_attr_name_list(src_table_name)):
-            return True
+        lhs = SQLiteSchemaExtractor(self.__dst_con).fetch_table_schema(src_table_name).as_dict()
+        rhs = SQLiteSchemaExtractor(src_con).fetch_table_schema(src_table_name).as_dict()
 
-        con_schema_extractor = SqliteSchemaExtractor(self.__dst_con, verbosity_level=1)
-        con_mem_schema_extractor = SqliteSchemaExtractor(src_con, verbosity_level=1)
-
-        if (con_schema_extractor.get_database_schema() ==
-                con_mem_schema_extractor.get_database_schema()):
-            return False
-
-        return True
+        return lhs != rhs
 
     def __make_unique_table_name(self, table_name_base):
         exist_table_name_list = self.__dst_con.fetch_table_name_list()

sqlitebiter/subcommand/_base.py

@@ -6,7 +6,10 @@
 
 from __future__ import absolute_import, unicode_literals
 
-from .._common import get_schema_extractor
+from textwrap import indent
+
+from sqliteschema import SQLiteSchemaExtractor
+
 from .._const import MAX_VERBOSITY_LEVEL, PROGRAM_NAME
 from .._counter import ResultCounter
 from .._table_creator import TableCreator
@@ -26,7 +29,7 @@ def __init__(self, logger, con, index_list, verbosity_level, format_name=None, e
         self._format_name = format_name
         self._encoding = encoding
 
-        self._schema_extractor = get_schema_extractor(con, verbosity_level)
+        self._schema_extractor = SQLiteSchemaExtractor(con)
         self._result_counter = ResultCounter()
         self._table_creator = TableCreator(logger=self._logger, dst_con=con)
 
@@ -40,9 +43,28 @@ def write_completion_message(self):
         logger.debug("----- {:s} completed -----".format(PROGRAM_NAME))
         logger.info("number of created tables: {:d}".format(self._result_counter.success_count))
         if self._result_counter.success_count > 0:
+            output_format, verbosity_level = self.__get_dump_param()
             logger.info(database_path_msg)
-            logger.debug("----- database schema -----")
-            logger.debug(get_schema_extractor(
-                self._con.database_path, MAX_VERBOSITY_LEVEL).dumps())
+            logger.debug("----- database schema -----\n{}".format(
+                indent(self._schema_extractor.dumps(
+                    output_format=output_format, verbosity_level=verbosity_level), "    ")))
         else:
             logger.debug(database_path_msg)
+
+    def __get_dump_param(self):
+        found_ptw = True
+        try:
+            import pytablewriter  # noqa: W0611
+        except ImportError:
+            found_ptw = False
+
+        if found_ptw:
+            return ("rst_simple_table", self._verbosity_level)
+
+        if self._verbosity_level >= 1:
+            return ("text", MAX_VERBOSITY_LEVEL)
+
+        if self._verbosity_level == 0:
+            return ("text", 1)
+
+        raise ValueError("invalid verbosity_level: {}".format(self._verbosity_level))

sqlitebiter/subcommand/_file.py

@@ -53,8 +53,7 @@ def convert(self, file_path):
                 nb=load_ipynb_file(file_path, encoding=self._encoding))
             for table_name in con.fetch_table_name_list():
                 logger.info(get_success_message(
-                    verbosity_level, file_path,
-                    self._schema_extractor.get_table_schema_text(table_name)))
+                    file_path, self._schema_extractor, table_name, verbosity_level))
                 result_counter.inc_success()
             if result_counter.total_count == convert_count:
                 TABLE_NOT_FOUND_MSG_FORMAT.format(file_path)
@@ -88,8 +87,8 @@ def convert(self, file_path):
                     return
 
                 logger.info(get_success_message(
-                    verbosity_level, file_path,
-                    self._schema_extractor.get_table_schema_text(sqlite_tabledata.table_name)))
+                    file_path, self._schema_extractor, sqlite_tabledata.table_name,
+                    verbosity_level))
         except ptr.OpenError as e:
             logger.error("{:s}: open error: file={}, message='{}'".format(
                 e.__class__.__name__, file_path, str(e)))

sqlitebiter/subcommand/_gs.py

@@ -43,8 +43,8 @@ def convert(self, credentials, title):
                     result_counter.inc_fail()
 
                 logger.info(get_success_message(
-                    verbosity_level, "google sheets",
-                    self._schema_extractor.get_table_schema_text(sqlite_tabledata.table_name)))
+                    "google sheets", self._schema_extractor, sqlite_tabledata.table_name,
+                    verbosity_level))
         except ptr.OpenError as e:
             logger.error(msgfy.to_error_message(e))
             result_counter.inc_fail()

sqlitebiter/subcommand/_url.py

@@ -64,8 +64,8 @@ def convert(self, url):
             convert_nb(logger, con, result_counter, nb=load_ipynb_url(url, proxies=proxies))
             for table_name in con.fetch_table_name_list():
                 logger.info(get_success_message(
-                    verbosity_level, get_logging_url_path(url),
-                    self._schema_extractor.get_table_schema_text(table_name)))
+                    get_logging_url_path(url), self._schema_extractor, table_name,
+                    verbosity_level))
                 result_counter.inc_success()
             if result_counter.total_count == 0:
                 TABLE_NOT_FOUND_MSG_FORMAT.format(url)
@@ -106,8 +106,8 @@ def convert(self, url):
                     continue
 
                 logger.info(get_success_message(
-                    verbosity_level, get_logging_url_path(url),
-                    self._schema_extractor.get_table_schema_text(sqlite_tabledata.table_name)))
+                    get_logging_url_path(url), self._schema_extractor, sqlite_tabledata.table_name,
+                    verbosity_level))
         except ptr.ValidationError as e:
             is_fail = True
             if loader.format_name == "json":

test/test_file_subcommand.py

@@ -16,7 +16,7 @@
 from pytablereader.interface import TableLoader
 from sqlitebiter._enum import ExitCode
 from sqlitebiter.sqlitebiter import cmd
-from sqliteschema import SqliteSchemaExtractor
+from sqliteschema import SQLiteSchemaExtractor
 
 from .common import print_test_result, print_traceback
 from .dataset import *
@@ -288,10 +288,10 @@ def test_normal_format_ssv(self):
         [
             valid_csv_file_3_1, "aa,ac",
             dedent("""\
-                .. table:: valid_csv_3_1 (3 records)
+                .. table:: valid_csv_3_1
 
                     +--------------+---------+-----------+--------+------+-----+
-                    |Attribute name|Data type|Primary key|Not NULL|Unique|Index|
+                    |Attribute name|Data type|PRIMARY KEY|NOT NULL|UNIQUE|Index|
                     +==============+=========+===========+========+======+=====+
                     |aa            |REAL     |           |        |      |X    |
                     +--------------+---------+-----------+--------+------+-----+
@@ -314,7 +314,7 @@ def test_normal_index(self, file_creator, index_list, expected):
 
             assert result.exit_code == ExitCode.SUCCESS
 
-            extractor = SqliteSchemaExtractor(db_path)
+            extractor = SQLiteSchemaExtractor(db_path)
 
             print_test_result(expected=expected, actual=extractor.dumps())