Add type annotations for screens.components subpackage

.gitignore

@@ -4,3 +4,4 @@
 .mypy_cache/
 __pycache__
 .pytest_cache/
+.dir-locals.el

mypy.ini

@@ -0,0 +1,32 @@
+[mypy]
+mypy_path = stubs
+
+[mypy-sml_sync.screens.components.*]
+disallow_any_unimported = True
+disallow_untyped_defs = True
+
+[mypy-sml_sync.screens.components.tests.*]
+# Don't typecheck tests yet
+ignore_errors = True
+
+# Dependencies that don't have stubs yet
+[mypy-sml.*]
+ignore_missing_imports = True
+
+[mypy-watchdog.*]
+ignore_missing_imports = True
+
+[mypy-semantic-versions.*]
+ignore_missing_imports = True
+
+[mypy-daiquiri]
+ignore_missing_imports = True
+
+[mypy-semantic_version]
+ignore_missing_imports = True
+
+[mypy-pytest]
+ignore_missing_imports = True
+
+[mypy-paramiko]
+ignore_missing_imports = True

requirements.txt

@@ -1,7 +1,6 @@
 sml
 daiquiri
 paramiko
-inflect
 watchdog
 semantic_version
 git+https://github.com/jonathanslenders/[email protected]

setup.py

@@ -7,12 +7,19 @@
 with open(os.path.join(here, 'sml_sync', 'version.py')) as f:
     exec(f.read(), {}, version_ns)
 
+packages = [
+    'sml_sync',
+    'sml_sync.screens',
+    'sml_sync.cli',
+    'sml_sync.screens.components'
+]
+
 setup(
     name='sml_sync',
     version=version_ns['version'],
     description='SherlockML file synchronizer',
     author='ASI Data Science',
-    packages=['sml_sync', 'sml_sync.screens', 'sml_sync.cli'],
+    packages=packages,
     entry_points={
         'console_scripts': ['sml-sync=sml_sync:run']
     },
@@ -24,7 +31,6 @@
         'sml',
         'daiquiri',
         'paramiko',
-        'inflect',
         'watchdog',
         'semantic_version',
         'prompt_toolkit>=2.0'

sml_sync/file_trees.py

@@ -1,10 +1,9 @@
 
-import logging
 import os
 import stat
 from datetime import datetime
 
-from .models import DirectoryAttrs, FileAttrs, FsObject, FsObjectType
+from .models import FsObjectType, Difference, DifferenceType
 
 
 def get_remote_mtime(path, sftp):
@@ -37,18 +36,18 @@ def compare_file_trees(left, right):
     right_file_paths = {obj.path: obj for obj in right}
     left_only = [obj for obj in left if obj.path not in right_file_paths]
     for obj in left_only:
-        yield ('LEFT_ONLY', obj)
+        yield Difference(DifferenceType.LEFT_ONLY, left=obj, right=None)
     right_only = [obj for obj in right if obj.path not in left_file_paths]
     for obj in right_only:
-        yield ('RIGHT_ONLY', obj)
+        yield Difference(DifferenceType.RIGHT_ONLY, left=None, right=obj)
 
     for left_obj in left:
         if left_obj.path in right_file_paths:
             right_obj = right_file_paths[left_obj.path]
             if left_obj.obj_type != right_obj.obj_type:
-                yield ('TYPE_DIFFERENT', left_obj, right_obj)
-            elif (
-                    left_obj.attrs != right_obj.attrs and
-                    left_obj.obj_type == FsObjectType.FILE
-                ):
-                yield ('ATTRS_DIFFERENT', left_obj, right_obj)
+                yield Difference(
+                    DifferenceType.TYPE_DIFFERENT, left_obj, right_obj)
+            elif (left_obj.attrs != right_obj.attrs and
+                  left_obj.obj_type == FsObjectType.FILE):
+                yield Difference(
+                    DifferenceType.ATTRS_DIFFERENT, left_obj, right_obj)

sml_sync/models.py

@@ -19,8 +19,14 @@ def without_path_prefix(self, prefix):
             self.attrs
         )
 
+    def is_file(self):
+        return self.obj_type == FsObjectType.FILE
 
-FileAttrs = collections.namedtuple('FileAttrs', ['last_modified'])
+    def is_directory(self):
+        return self.obj_type == FsObjectType.DIRECTORY
+
+
+FileAttrs = collections.namedtuple('FileAttrs', ['last_modified', 'size'])
 DirectoryAttrs = collections.namedtuple('DirectoryAttrs', ['last_modified'])
 
 
@@ -41,3 +47,21 @@ class ChangeEventType(Enum):
     'FsChangeEvent',
     ['event_type', 'is_directory', 'path', 'extra_args']
 )
+
+
+class DifferenceType(Enum):
+    # path exists only in left tree
+    LEFT_ONLY = 'LEFT_ONLY'
+
+    # path exists only in right tree
+    RIGHT_ONLY = 'RIGHT_ONLY'
+
+    # path exists in both, but is a file in one and a directory in the other
+    TYPE_DIFFERENT = 'TYPE_DIFFERENT'
+
+    # path exists in both, but they have different attributes
+    ATTRS_DIFFERENT = 'ATTRS_DIFFERENT'
+
+
+Difference = collections.namedtuple(
+    'Difference', ['difference_type', 'left', 'right'])

sml_sync/screens/choose_remote_dir.py

@@ -7,11 +7,9 @@
 from enum import Enum
 from queue import Empty, Queue
 
-from prompt_toolkit.application.current import get_app
+from prompt_toolkit.application import get_app
 from prompt_toolkit.key_binding import KeyBindings
-from prompt_toolkit.layout import HSplit, VSplit
-from prompt_toolkit.layout.containers import Window
-from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.layout import HSplit, VSplit, Window, FormattedTextControl
 from prompt_toolkit.widgets import TextArea
 
 from ..pubsub import Messages

sml_sync/screens/components/__init__.py

@@ -0,0 +1,3 @@
+
+from .table import Table, TableColumn, ColumnSettings, Alignment  # noqa
+from .vertical_menu import MenuEntry, VerticalMenu  # noqa

sml_sync/screens/components/table.py

@@ -0,0 +1,112 @@
+from collections import namedtuple
+import itertools
+from enum import Enum
+from typing import List, Optional
+
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.document import Document
+from prompt_toolkit.layout import (
+    Window, HSplit, FormattedTextControl, BufferControl, ScrollbarMargin,
+    Container
+)
+
+
+class Alignment(Enum):
+    RIGHT = 'RIGHT'
+    LEFT = 'LEFT'
+
+
+class ColumnSettings(object):
+
+    def __init__(self, alignment: Alignment = Alignment.LEFT) -> None:
+        self.alignment = alignment
+
+
+class TableColumn(
+        namedtuple('Column', ['rows', 'header', 'settings'])):
+
+    def __new__(
+            cls, rows: List[str],
+            header: str,
+            settings: Optional[ColumnSettings] = None
+    ) -> 'TableColumn':
+        if settings is None:
+            settings = ColumnSettings()
+        return super(TableColumn, cls).__new__(cls, rows, header, settings)
+
+
+class Table(object):
+
+    def __init__(self, columns: List[TableColumn], sep: str = ' ') -> None:
+        if len(set(len(column.rows) for column in columns)) not in {0, 1}:
+            raise ValueError('All columns must have the same number of rows.')
+
+        self._sep = sep
+
+        formatted_headers = []
+        formatted_columns = []
+        for column in columns:
+            width = self._get_column_width(column)
+            formatted_rows = [
+                self._format_cell(row, column.settings, width)
+                for row in column.rows
+            ]
+            formatted_headers.append(column.header.ljust(width, ' '))
+            formatted_columns.append(formatted_rows)
+
+        self.window = HSplit(
+            self._header_windows(formatted_headers) +
+            self._body_windows(formatted_columns)
+        )
+
+    def _get_column_width(self, column: TableColumn) -> int:
+        width = max(
+            len(column.header),
+            max((len(row) for row in column.rows), default=0)
+        )
+        return width
+
+    def _format_cell(
+            self,
+            content: str,
+            column_settings: ColumnSettings,
+            width: int
+    ) -> str:
+        if column_settings.alignment == Alignment.LEFT:
+            return content.ljust(width)
+        else:
+            return content.rjust(width)
+
+    def _header_windows(self, formatted_headers: List[str]) -> List[Window]:
+        if len(formatted_headers):
+            header_control = FormattedTextControl(
+                self._sep.join(formatted_headers))
+            header_windows = [Window(header_control, height=1)]
+        else:
+            header_windows = [Window(height=1, width=0)]
+        return header_windows
+
+    def _body_windows(
+            self,
+            formatted_columns: List[List[str]]
+    ) -> List[Window]:
+        rows = list(itertools.zip_longest(*formatted_columns, fillvalue=''))
+        if rows:
+            rows_string = [self._sep.join(row) for row in rows]
+            table_body = '\n'.join(rows_string)
+
+            document = Document(table_body, cursor_position=0)
+            _buffer = Buffer(document=document, read_only=True)
+            self._body_control = BufferControl(_buffer)
+            body_windows = [
+                Window(
+                    self._body_control,
+                    right_margins=[ScrollbarMargin(display_arrows=True)]
+                )
+            ]
+        else:
+            body_windows = []
+        return body_windows
+
+    def __pt_container__(self) -> Container:
+        return self.window