Black, removed six usage.

Author: jonathanslenders

pymux/__init__.py

@@ -1 +0,0 @@
-from __future__ import unicode_literals

pymux/__main__.py

@@ -1,8 +1,7 @@
 """
 Make sure `python -m pymux` works.
 """
-from __future__ import unicode_literals
 from .entry_points.run_pymux import run
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     run()

pymux/arrangement.py

@@ -7,45 +7,46 @@
 An arrangement consists of a list of windows. And a window has a list of panes,
 arranged by ordering them in HSplit/VSplit instances.
 """
-from __future__ import unicode_literals
-
-from ptterm import Terminal
-from prompt_toolkit.application.current import get_app, get_app_or_none, set_app
-from prompt_toolkit.buffer import Buffer
-
 import math
 import os
 import weakref
-import six
+from typing import Optional
+
+from prompt_toolkit.application.current import get_app, get_app_or_none, set_app
+from prompt_toolkit.buffer import Buffer
+from ptterm import Terminal
 
 __all__ = (
-    'LayoutTypes',
-    'Pane',
-    'HSplit',
-    'VSplit',
-    'Window',
-    'Arrangement',
+    "LayoutTypes",
+    "Pane",
+    "HSplit",
+    "VSplit",
+    "Window",
+    "Arrangement",
 )
 
 
 class LayoutTypes:
     # The values are in lowercase with dashes, because that is what users can
     # use at the command line.
-    EVEN_HORIZONTAL = 'even-horizontal'
-    EVEN_VERTICAL = 'even-vertical'
-    MAIN_HORIZONTAL = 'main-horizontal'
-    MAIN_VERTICAL = 'main-vertical'
-    TILED = 'tiled'
+    EVEN_HORIZONTAL = "even-horizontal"
+    EVEN_VERTICAL = "even-vertical"
+    MAIN_HORIZONTAL = "main-horizontal"
+    MAIN_VERTICAL = "main-vertical"
+    TILED = "tiled"
 
     _ALL = [EVEN_HORIZONTAL, EVEN_VERTICAL, MAIN_HORIZONTAL, MAIN_VERTICAL, TILED]
 
 
-class Pane(object):
+class Pane:
     """
     One pane, containing one process and a search buffer for going into copy
     mode or displaying the help.
     """
-    _pane_counter = 1000  # Start at 1000, to be sure to not confuse this with pane indexes.
+
+    _pane_counter = (
+        1000  # Start at 1000, to be sure to not confuse this with pane indexes.
+    )
 
     def __init__(self, terminal=None):
         assert isinstance(terminal, Terminal)
@@ -68,7 +69,7 @@ def __init__(self, terminal=None):
         self.scroll_buffer = Buffer(read_only=True)
         self.copy_get_tokens_for_line = lambda lineno: []
         self.display_scroll_buffer = False
-        self.scroll_buffer_title = ''
+        self.scroll_buffer_title = ""
 
     @property
     def process(self):
@@ -88,7 +89,7 @@ def name(self):
             if name:
                 return os.path.basename(name)
 
-        return ''
+        return ""
 
     def enter_copy_mode(self):
         """
@@ -114,6 +115,7 @@ class _WeightsDictionary(weakref.WeakKeyDictionary):
     This dictionary maps the child (another HSplit/VSplit or Pane), to the
     size. (Integer.)
     """
+
     def __getitem__(self, key):
         try:
             # (Don't use 'super' here. This is a classobj in Python2.)
@@ -127,6 +129,7 @@ class _Split(list):
     Base class for horizontal and vertical splits. (This is a higher level
     split than prompt_toolkit.layout.HSplit.)
     """
+
     def __init__(self, *a, **kw):
         list.__init__(self, *a, **kw)
 
@@ -138,7 +141,7 @@ def __hash__(self):
         return id(self)
 
     def __repr__(self):
-        return '%s(%s)' % (self.__class__.__name__, list.__repr__(self))
+        return "%s(%s)" % (self.__class__.__name__, list.__repr__(self))
 
 
 class HSplit(_Split):
@@ -153,6 +156,7 @@ class Window(object):
     """
     Pymux window.
     """
+
     _window_counter = 1000  # Start here, to avoid confusion with window index.
 
     def __init__(self, index=0):
@@ -178,24 +182,27 @@ def invalidation_hash(self):
         Return a hash (string) that can be used to determine when the layout
         has to be rebuild.
         """
-#        if not self.root:
-#            return '<empty-window>'
+        #        if not self.root:
+        #            return '<empty-window>'
 
         def _hash_for_split(split):
             result = []
             for item in split:
                 if isinstance(item, (VSplit, HSplit)):
                     result.append(_hash_for_split(item))
                 elif isinstance(item, Pane):
-                    result.append('p%s' % item.pane_id)
+                    result.append("p%s" % item.pane_id)
 
             if isinstance(split, HSplit):
-                return 'HSplit(%s)' % (','.join(result))
+                return "HSplit(%s)" % (",".join(result))
             else:
-                return 'VSplit(%s)' % (','.join(result))
+                return "VSplit(%s)" % (",".join(result))
 
-        return '<window_id=%s,zoom=%s,children=%s>' % (
-            self.window_id, self.zoom, _hash_for_split(self.root))
+        return "<window_id=%s,zoom=%s,children=%s>" % (
+            self.window_id,
+            self.zoom,
+            _hash_for_split(self.root),
+        )
 
     @property
     def active_pane(self):
@@ -240,7 +247,7 @@ def name(self):
             if pane:
                 return pane.name
 
-        return ''
+        return ""
 
     def add_pane(self, pane, vsplit=False):
         """
@@ -354,7 +361,9 @@ def focus_next(self, count=1):
         " Focus the next pane. "
         panes = self.panes
         if panes:
-            self.active_pane = panes[(panes.index(self.active_pane) + count) % len(panes)]
+            self.active_pane = panes[
+                (panes.index(self.active_pane) + count) % len(panes)
+            ]
         else:
             self.active_pane = None  # No panes left.
 
@@ -381,10 +390,10 @@ def rotate(self, count=1, with_pane_before_only=False, with_pane_after_only=Fals
 
         # Only before after? Reduce list of panes.
         if with_pane_before_only:
-            items = items[current_pane_index - 1:current_pane_index + 1]
+            items = items[current_pane_index - 1 : current_pane_index + 1]
 
         elif with_pane_after_only:
-            items = items[current_pane_index:current_pane_index + 2]
+            items = items[current_pane_index : current_pane_index + 2]
 
         # Rotate positions.
         for i, triple in enumerate(items):
@@ -417,22 +426,26 @@ def select_layout(self, layout_type):
 
         # main-horizontal.
         elif layout_type == LayoutTypes.MAIN_HORIZONTAL:
-            self.root = HSplit([
-                self.active_pane,
-                VSplit([p for p in self.panes if p != self.active_pane])
-            ])
+            self.root = HSplit(
+                [
+                    self.active_pane,
+                    VSplit([p for p in self.panes if p != self.active_pane]),
+                ]
+            )
 
         # main-vertical.
         elif layout_type == LayoutTypes.MAIN_VERTICAL:
-            self.root = VSplit([
-                self.active_pane,
-                HSplit([p for p in self.panes if p != self.active_pane])
-            ])
+            self.root = VSplit(
+                [
+                    self.active_pane,
+                    HSplit([p for p in self.panes if p != self.active_pane]),
+                ]
+            )
 
         # tiled.
         elif layout_type == LayoutTypes.TILED:
             panes = self.panes
-            column_count = math.ceil(len(panes) ** .5)
+            column_count = math.ceil(len(panes) ** 0.5)
 
             rows = HSplit()
             current_row = VSplit()
@@ -495,9 +508,11 @@ def find_split_and_child(split_cls, is_before):
             split = self._get_parent(child)
 
             def found():
-                return isinstance(split, split_cls) and (
-                    not is_before or split.index(child) > 0) and (
-                        is_before or split.index(child) < len(split) - 1)
+                return (
+                    isinstance(split, split_cls)
+                    and (not is_before or split.index(child) > 0)
+                    and (is_before or split.index(child) < len(split) - 1)
+                )
 
             while split and not found():
                 child = split
@@ -532,8 +547,9 @@ def handle_side(split_cls, is_before, amount, trying_other_side=False):
                     # case it's logical to move the left border to the right
                     # instead.
                     if not trying_other_side:
-                        handle_side(split_cls, not is_before, -amount,
-                                    trying_other_side=True)
+                        handle_side(
+                            split_cls, not is_before, -amount, trying_other_side=True
+                        )
 
         handle_side(VSplit, True, left)
         handle_side(VSplit, False, right)
@@ -553,6 +569,7 @@ class Arrangement(object):
     window. All the clients share the same Arrangement instance, but they can
     have different windows active.
     """
+
     def __init__(self):
         self.windows = []
         self.base_index = 0
@@ -569,7 +586,7 @@ def invalidation_hash(self):
         When this changes, the layout needs to be rebuild.
         """
         if not self.windows:
-            return '<no-windows>'
+            return "<no-windows>"
 
         w = self.get_active_window()
         return w.invalidation_hash()
@@ -583,7 +600,9 @@ def get_active_window(self):
         try:
             return self._active_window_for_cli[app]
         except KeyError:
-            self._active_window_for_cli[app] = self._last_active_window or self.windows[0]
+            self._active_window_for_cli[app] = (
+                self._last_active_window or self.windows[0]
+            )
             return self.windows[0]
 
     def set_active_window(self, window):
@@ -621,17 +640,14 @@ def get_window_by_index(self, index):
             if w.index == index:
                 return w
 
-    def create_window(self, pane, name=None, set_active=True):
+    def create_window(self, pane: Pane, name: Optional[str] = None, set_active=True):
         """
         Create a new window that contains just this pane.
 
         :param pane: The :class:`.Pane` instance to put in the new window.
         :param name: If given, name for the new window.
         :param set_active: When True, focus the new window.
         """
-        assert isinstance(pane, Pane)
-        assert name is None or isinstance(name, six.text_type)
-
         # Take the first available index.
         taken_indexes = [w.index for w in self.windows]
 
@@ -700,14 +716,16 @@ def remove_pane(self, pane):
     def focus_previous_window(self):
         w = self.get_active_window()
 
-        self.set_active_window(self.windows[
-            (self.windows.index(w) - 1) % len(self.windows)])
+        self.set_active_window(
+            self.windows[(self.windows.index(w) - 1) % len(self.windows)]
+        )
 
     def focus_next_window(self):
         w = self.get_active_window()
 
-        self.set_active_window(self.windows[
-            (self.windows.index(w) + 1) % len(self.windows)])
+        self.set_active_window(
+            self.windows[(self.windows.index(w) + 1) % len(self.windows)]
+        )
 
     def break_pane(self, set_active=True):
         """

pymux/client/__init__.py

@@ -1,3 +1,2 @@
-from __future__ import unicode_literals
 from .base import Client
 from .defaults import create_client, list_clients

pymux/client/base.py

@@ -1,16 +1,13 @@
-from __future__ import unicode_literals
+from abc import ABC
 
 from prompt_toolkit.output import ColorDepth
-from abc import ABCMeta
-from six import with_metaclass
-
 
 __all__ = [
-    'Client',
+    "Client",
 ]
 
 
-class Client(with_metaclass(ABCMeta, object)):
+class Client(ABC):
     def run_command(self, command, pane_id=None):
         """
         Ask the server to run this command.

pymux/client/defaults.py

@@ -1,24 +1,28 @@
-from __future__ import unicode_literals
 from prompt_toolkit.utils import is_windows
+
 __all__ = [
-    'create_client',
-    'list_clients',
+    "create_client",
+    "list_clients",
 ]
 
 
 def create_client(socket_name):
     if is_windows():
         from .windows import WindowsClient
+
         return WindowsClient(socket_name)
     else:
         from .posix import PosixClient
+
         return PosixClient(socket_name)
 
 
 def list_clients():
     if is_windows():
         from .windows import list_clients
+
         return list_clients()
     else:
         from .posix import list_clients
+
         return list_clients()