Fix PEP8 empty line errors

bersace · bersace · commit e124c035756d · 2017-06-14T18:12:05.000+02:00
diff --git a/pgcli/completion_refresher.py b/pgcli/completion_refresher.py
@@ -100,34 +100,41 @@ def wrapper(wrapped):
         return wrapped
     return wrapper
 
+
 @refresher('schemata')
 def refresh_schemata(completer, executor):
     completer.set_search_path(executor.search_path())
     completer.extend_schemata(executor.schemata())
 
+
 @refresher('tables')
 def refresh_tables(completer, executor):
     completer.extend_relations(executor.tables(), kind='tables')
     completer.extend_columns(executor.table_columns(), kind='tables')
     completer.extend_foreignkeys(executor.foreignkeys())
 
+
 @refresher('views')
 def refresh_views(completer, executor):
     completer.extend_relations(executor.views(), kind='views')
     completer.extend_columns(executor.view_columns(), kind='views')
 
+
 @refresher('functions')
 def refresh_functions(completer, executor):
     completer.extend_functions(executor.functions())
 
+
 @refresher('types')
 def refresh_types(completer, executor):
     completer.extend_datatypes(executor.datatypes())
 
+
 @refresher('databases')
 def refresh_databases(completer, executor):
     completer.extend_database_names(executor.databases())
 
+
 @refresher('casing')
 def refresh_casing(completer, executor):
     casing_file = completer.casing_file
diff --git a/pgcli/encodingutils.py b/pgcli/encodingutils.py
@@ -3,6 +3,7 @@
 PY2 = sys.version_info[0] == 2
 PY3 = sys.version_info[0] == 3
 
+
 def unicode2utf8(arg):
     """
     Only in Python 2. Psycopg2 expects the args as bytes not unicode.
@@ -13,6 +14,7 @@ def unicode2utf8(arg):
         return arg.encode('utf-8')
     return arg
 
+
 def utf8tounicode(arg):
     """
     Only in Python 2. Psycopg2 returns the error message as utf-8.
diff --git a/pgcli/filters.py b/pgcli/filters.py
@@ -1,5 +1,6 @@
 from prompt_toolkit.filters import Filter
 
+
 class HasSelectedCompletion(Filter):
     """Enable when the current buffer has a selected completion."""
 
diff --git a/pgcli/magic.py b/pgcli/magic.py
@@ -58,12 +58,5 @@ def pgcli_line_magic(line):
         _logger.debug('Dangerous query detected -- ignoring')
         return
 
-
     ipython = get_ipython()
     return ipython.run_cell_magic('sql', line, q.query)
-
-
-
-
-
-
diff --git a/pgcli/packages/expanded.py b/pgcli/packages/expanded.py
@@ -1,9 +1,11 @@
 from .tabulate import _text_type
 from ..encodingutils import utf8tounicode
 
+
 def pad(field, total, char=u" "):
     return field + (char * (total - len(field)))
 
+
 def expanded_table(rows, headers, missingval=""):
     header_len = max([len(x) for x in headers])
     max_row_len = 0
diff --git a/pgcli/packages/ordereddict.py b/pgcli/packages/ordereddict.py
@@ -22,6 +22,7 @@
 
 from UserDict import DictMixin
 
+
 class OrderedDict(dict, DictMixin):
 
     def __init__(self, *args, **kwds):
diff --git a/pgcli/packages/parseutils/ctes.py b/pgcli/packages/parseutils/ctes.py
@@ -140,9 +140,3 @@ def _identifiers(tok):
                 yield t
     elif isinstance(tok, Identifier):
         yield tok
-
-
-
-
-
-
diff --git a/pgcli/packages/parseutils/utils.py b/pgcli/packages/parseutils/utils.py
@@ -15,6 +15,7 @@
         'all_punctuations': re.compile('([^\s]+)$'),
         }
 
+
 def last_word(text, include='alphanum_underscore'):
     """
     Find the last word in a sentence.
@@ -137,4 +138,3 @@ def parse_partial_identifier(word):
         return parse_partial_identifier(word + '"')
     else:
         return None
-
diff --git a/pgcli/packages/pgliterals/__init__.py b/pgcli/packages/pgliterals/__init__.py
@@ -1,2 +0,0 @@
-
-
diff --git a/pgcli/packages/prioritization.py b/pgcli/packages/prioritization.py
@@ -14,6 +14,7 @@ def _compile_regex(keyword):
     pattern = '\\b' + white_space_regex.sub(r'\\s+', keyword) + '\\b'
     return re.compile(pattern, re.MULTILINE | re.IGNORECASE)
 
+
 keywords = get_literals('keywords')
 keyword_regexs = dict((kw, _compile_regex(kw)) for kw in keywords)
 
@@ -48,6 +49,3 @@ def keyword_count(self, keyword):
 
     def name_count(self, name):
         return self.name_counts[name]
-
-
-
diff --git a/pgcli/packages/sqlcompletion.py b/pgcli/packages/sqlcompletion.py
@@ -170,6 +170,7 @@ def _strip_named_query(txt):
         txt = named_query_regex.sub('', txt)
     return txt
 
+
 function_body_pattern = re.compile('(\\$.*?\\$)([\s\S]*?)\\1', re.M)
 
 
@@ -236,6 +237,7 @@ def _split_multiple_statements(full_text, text_before_cursor, parsed):
     'sf': Function,
 }
 
+
 def suggest_special(text):
     text = text.lstrip()
     cmd, _, arg = parse_special_command(text)
diff --git a/pgcli/packages/tabulate.py b/pgcli/packages/tabulate.py
@@ -311,6 +311,7 @@ def _isint(string):
     """
     return type(string) is _int_type or type(string) is _long_type
 
+
 def _type(string, has_invisible=True):
     """The least generic type (type(None), int, float, str, unicode).
 
diff --git a/pgcli/pgcompleter.py b/pgcli/pgcompleter.py
@@ -30,6 +30,8 @@
 
 Match = namedtuple('Match', ['completion', 'priority'])
 _SchemaObject = namedtuple('SchemaObject', ['name', 'schema', 'function'])
+
+
 def SchemaObject(name, schema=None, function=False):
     return _SchemaObject(name, schema, function)
 
@@ -50,6 +52,7 @@ def generate_alias(tbl):
     return ''.join([l for l in tbl if l.isupper()] or
         [l for l, prev in zip(tbl,  '_' + tbl) if prev == '_' and l != '_'])
 
+
 class PGCompleter(Completer):
     # keywords_tree: A dict mapping keywords to well known following keywords.
     # e.g. 'CREATE': ['TABLE', 'USER', ...],
@@ -827,6 +830,3 @@ def populate_functions(self, schema, filter_func):
             for meta in metas
             if filter_func(meta)
         ]
-
-
-
diff --git a/pgcli/pgtoolbar.py b/pgcli/pgtoolbar.py
@@ -2,6 +2,7 @@
 from prompt_toolkit.enums import DEFAULT_BUFFER
 from prompt_toolkit.key_binding.vi_state import InputMode
 
+
 def _get_vi_mode(cli):
     return {
         InputMode.INSERT: 'I',
@@ -10,6 +11,7 @@ def _get_vi_mode(cli):
         InputMode.INSERT_MULTIPLE: 'M',
     }[cli.vi_state.input_mode]
 
+
 def create_toolbar_tokens_func(get_vi_mode_enabled, get_is_refreshing,
                                failed_transaction, valid_transaction):
     """
diff --git a/tests/conftest.py b/tests/conftest.py
@@ -29,5 +29,3 @@ def executor(connection):
 @pytest.fixture
 def exception_formatter():
     return lambda e: str(e)
-
-
diff --git a/tests/features/steps/basic_commands.py b/tests/features/steps/basic_commands.py
@@ -21,6 +21,7 @@ def step_run_cli(context):
 def step_wait_prompt(context):
     wrappers.wait_prompt(context)
 
+
 @when('we send "ctrl + d"')
 def step_ctrl_d(context):
     """
diff --git a/tests/parseutils/test_ctes.py b/tests/parseutils/test_ctes.py
@@ -117,5 +117,3 @@ def test_multiple_cte_extraction():
     assert tuple(ctes) == (
         ('x', ('abc', 'def'), start1, stop1),
         ('y', ('ghi', 'jkl'), start2, stop2))
-
-
diff --git a/tests/parseutils/test_parseutils.py b/tests/parseutils/test_parseutils.py
@@ -2,10 +2,12 @@
 from pgcli.packages.parseutils.tables import extract_tables
 from pgcli.packages.parseutils.utils import find_prev_keyword, is_open_quote
 
+
 def test_empty_string():
     tables = extract_tables('')
     assert tables == ()
 
+
 def test_simple_select_single_table():
     tables = extract_tables('select * from abc')
     assert tables == ((None, 'abc', None, False),)
@@ -33,62 +35,75 @@ def test_simple_select_single_table_double_quoted():
     tables = extract_tables('select * from "Abc"')
     assert tables == ((None, 'Abc', None, False),)
 
+
 def test_simple_select_multiple_tables():
     tables = extract_tables('select * from abc, def')
     assert set(tables) == set([(None, 'abc', None, False),
                                (None, 'def', None, False)])
 
+
 def test_simple_select_multiple_tables_double_quoted():
     tables = extract_tables('select * from "Abc", "Def"')
     assert set(tables) == set([(None, 'Abc', None, False),
                                (None, 'Def', None, False)])
 
+
 def test_simple_select_single_table_deouble_quoted_aliased():
     tables = extract_tables('select * from "Abc" a')
     assert tables == ((None, 'Abc', 'a', False),)
 
+
 def test_simple_select_multiple_tables_deouble_quoted_aliased():
     tables = extract_tables('select * from "Abc" a, "Def" d')
     assert set(tables) == set([(None, 'Abc', 'a', False),
                                (None, 'Def', 'd', False)])
 
+
 def test_simple_select_multiple_tables_schema_qualified():
     tables = extract_tables('select * from abc.def, ghi.jkl')
     assert set(tables) == set([('abc', 'def', None, False),
                                ('ghi', 'jkl', None, False)])
 
+
 def test_simple_select_with_cols_single_table():
     tables = extract_tables('select a,b from abc')
     assert tables == ((None, 'abc', None, False),)
 
+
 def test_simple_select_with_cols_single_table_schema_qualified():
     tables = extract_tables('select a,b from abc.def')
     assert tables == (('abc', 'def', None, False),)
 
+
 def test_simple_select_with_cols_multiple_tables():
     tables = extract_tables('select a,b from abc, def')
     assert set(tables) == set([(None, 'abc', None, False),
                                (None, 'def', None, False)])
 
+
 def test_simple_select_with_cols_multiple_qualified_tables():
     tables = extract_tables('select a,b from abc.def, def.ghi')
     assert set(tables) == set([('abc', 'def', None, False),
                                ('def', 'ghi', None, False)])
 
+
 def test_select_with_hanging_comma_single_table():
     tables = extract_tables('select a, from abc')
     assert tables == ((None, 'abc', None, False),)
 
+
 def test_select_with_hanging_comma_multiple_tables():
     tables = extract_tables('select a, from abc, def')
     assert set(tables) == set([(None, 'abc', None, False),
                                (None, 'def', None, False)])
 
+
 def test_select_with_hanging_period_multiple_tables():
     tables = extract_tables('SELECT t1. FROM tabl1 t1, tabl2 t2')
     assert set(tables) == set([(None, 'tabl1', 't1', False),
                                (None, 'tabl2', 't2', False)])
 
+
 def test_simple_insert_single_table():
     tables = extract_tables('insert into abc (id, name) values (1, "def")')
 
@@ -98,26 +113,31 @@ def test_simple_insert_single_table():
 
     assert tables == ((None, 'abc', 'abc', False),)
 
+
 @pytest.mark.xfail
 def test_simple_insert_single_table_schema_qualified():
     tables = extract_tables('insert into abc.def (id, name) values (1, "def")')
     assert tables == (('abc', 'def', None, False),)
 
+
 def test_simple_update_table_no_schema():
     tables = extract_tables('update abc set id = 1')
     assert tables == ((None, 'abc', None, False),)
 
+
 def test_simple_update_table_with_schema():
     tables = extract_tables('update abc.def set id = 1')
     assert tables == (('abc', 'def', None, False),)
 
+
 @pytest.mark.parametrize('join_type', ['', 'INNER', 'LEFT', 'RIGHT OUTER'])
 def test_join_table(join_type):
     sql = 'SELECT * FROM abc a {0} JOIN def d ON a.id = d.num'.format(join_type)
     tables = extract_tables(sql)
     assert set(tables) == set([(None, 'abc', 'a', False),
                                (None, 'def', 'd', False)])
 
+
 def test_join_table_schema_qualified():
     tables = extract_tables('SELECT * FROM abc.def x JOIN ghi.jkl y ON x.id = y.num')
     assert set(tables) == set([('abc', 'def', 'x', False),
@@ -156,21 +176,25 @@ def test_subselect_tables():
     tables = extract_tables(sql)
     assert tables == ((None, 'abc', None, False),)
 
+
 @pytest.mark.parametrize('text', ['SELECT * FROM foo.', 'SELECT 123 AS foo'])
 def test_extract_no_tables(text):
     tables = extract_tables(text)
     assert tables == tuple()
 
+
 @pytest.mark.parametrize('arg_list', ['', 'arg1', 'arg1, arg2, arg3'])
 def test_simple_function_as_table(arg_list):
     tables = extract_tables('SELECT * FROM foo({0})'.format(arg_list))
     assert tables == ((None, 'foo', None, True),)
 
+
 @pytest.mark.parametrize('arg_list', ['', 'arg1', 'arg1, arg2, arg3'])
 def test_simple_schema_qualified_function_as_table(arg_list):
     tables = extract_tables('SELECT * FROM foo.bar({0})'.format(arg_list))
     assert tables == (('foo', 'bar', None, True),)
 
+
 @pytest.mark.parametrize('arg_list', ['', 'arg1', 'arg1, arg2, arg3'])
 def test_simple_aliased_function_as_table(arg_list):
     tables = extract_tables('SELECT * FROM foo({0}) bar'.format(arg_list))
@@ -182,19 +206,20 @@ def test_simple_table_and_function():
     assert set(tables) == set([(None, 'foo', None, False),
                                (None, 'bar', None, True)])
 
+
 def test_complex_table_and_function():
     tables = extract_tables('''SELECT * FROM foo.bar baz
                                JOIN bar.qux(x, y, z) quux''')
     assert set(tables) == set([('foo', 'bar', 'baz', False),
                                ('bar', 'qux', 'quux', True)])
 
 
-
 def test_find_prev_keyword_using():
     q = 'select * from tbl1 inner join tbl2 using (col1, '
     kw, q2 = find_prev_keyword(q)
     assert kw.value == '(' and q2 == 'select * from tbl1 inner join tbl2 using ('
 
+
 @pytest.mark.parametrize('sql', [
     'select * from foo where bar',
     'select * from foo where bar = 1 and baz or ',
diff --git a/tests/test_expanded.py b/tests/test_expanded.py
diff --git a/tests/test_fuzzy_completion.py b/tests/test_fuzzy_completion.py
diff --git a/tests/test_main.py b/tests/test_main.py
diff --git a/tests/test_naive_completion.py b/tests/test_naive_completion.py
diff --git a/tests/test_pgexecute.py b/tests/test_pgexecute.py
diff --git a/tests/test_smart_completion_multiple_schemata.py b/tests/test_smart_completion_multiple_schemata.py
diff --git a/tests/test_smart_completion_public_schema_only.py b/tests/test_smart_completion_public_schema_only.py
diff --git a/tests/test_sqlcompletion.py b/tests/test_sqlcompletion.py
