refactoring and migrating to python-3.5

Author: Doka-NT

Application.py

@@ -0,0 +1,45 @@
+from os.path import expanduser, sep
+
+from ssh_manager.ConfigurationFile import ConfigurationFile
+from ssh_manager.JsonConfigParser import JsonConfigParser
+from ssh_manager.Manager import Manager
+from ssh_manager.config.Config import Config
+from ssh_manager.interfaces.AbstractApplication import AbstractApplication
+from ui.ConnectionListWindow import ConnectionListWindow
+
+
+class Application(AbstractApplication):
+    def run(self):
+        config_file_path = self.get_config_file_path()
+        config = self.get_config(config_file_path)
+        manager = self.get_manager(config)
+
+        window = ConnectionListWindow(manager, config.get_window())
+        window.show()
+
+    @staticmethod
+    def get_config_file_path() -> str:
+        home = expanduser("~")
+        return home + sep + '_______sshManager.config.json'
+
+    @staticmethod
+    def get_manager(config: Config):
+        connections = config.get_connections()
+        manager = Manager(connections)
+
+        return manager
+
+    @staticmethod
+    def get_config(file_path: str) -> Config:
+        file = ConfigurationFile(file_path)
+        parser = JsonConfigParser()
+        config = parser.parse(file)
+
+        return config
+
+    @staticmethod
+    def create_default_manager():
+        config = Application.get_config(Application.get_config_file_path())
+        manager = Application.get_manager(config)
+
+        return manager

app.py

@@ -1,14 +1,6 @@
-#!/usr/bin/python
-# simple.py
+#!/usr/bin/python3.5
 
-import sys
-from PyQt4 import QtGui
+from Application import Application
 
-from SshManager import SshManager
-
-app = QtGui.QApplication(sys.argv)
-
-sshManager = SshManager()
-sshManager.show()
-
-sys.exit(app.exec_())
+app = Application()
+app.run()

requirements.txt

@@ -5,7 +5,9 @@
       "-x",
       "ssh"
     ],
-    "edit": ["xdg-open"]
+    "edit": [
+      "xdg-open"
+    ]
   },
   "window": {
     "x": 300,
@@ -23,7 +25,8 @@
       "host": "localhost",
       "label": "Localhost with default port",
       "args": [
-        "-l", "my_username"
+        "-l",
+        "my_username"
       ]
     }
   ]

config-dist.json resources/config-dist.json

@@ -0,0 +1,23 @@
+from os.path import exists, dirname
+from shutil import copy
+
+from ssh_manager.interfaces.AbstractConfigurationFile import AbstractConfigurationFile
+
+
+class ConfigurationFile(AbstractConfigurationFile):
+    _file_path = ''
+
+    def __init__(self, file_path):
+        super(ConfigurationFile, self).__init__()
+        self._file_path = file_path
+        self._create_if_not_exists()
+
+    def get_contents(self):
+        with open(self._file_path, 'r') as opened_file:
+            return opened_file.read()
+
+    def _create_if_not_exists(self):
+        if exists(self._file_path):
+            return
+        dist_file = dirname(__file__) + '/../resources/config-dist.json'
+        copy(dist_file, self._file_path)

screenshot.png

@@ -0,0 +1,10 @@
+class Connection:
+    DEFAULT_PORT = 22
+    label = ''
+    host = ''
+    port = 0
+
+    def __init__(self, label: str, host: str, port: int):
+        self.label = label
+        self.host = host
+        self.port = port

ssh_manager/ConfigurationFile.py

@@ -0,0 +1,33 @@
+from json import loads
+
+from ssh_manager import ConfigurationFile
+from ssh_manager.Connection import Connection
+from ssh_manager.config.Config import Config
+from ssh_manager.config.Window import Window
+from ssh_manager.interfaces.AbstractConfigParser import AbstractConfigParser
+
+
+class JsonConfigParser(AbstractConfigParser):
+    def parse(self, file: ConfigurationFile) -> Config:
+        config = Config()
+        json_object = loads(file.get_contents())
+
+        self._parse_connections(json_object, config)
+        self._parse_window(json_object, config)
+
+        return config
+
+    @staticmethod
+    def _parse_connections(json_object: dict, config: Config):
+        config.set_connections([])
+        for _connection in json_object['connections']:
+            if 'port' not in _connection:
+                _connection['port'] = Connection.DEFAULT_PORT
+            connection = Connection(_connection['label'], _connection['host'], _connection['port'])
+            config.add_connection(connection)
+
+    @staticmethod
+    def _parse_window(json_object: dict, config: Config):
+        _window = json_object['window']
+        window = Window(_window['x'], _window['y'], _window['width'], _window['height'])
+        config.set_window(window)

ssh_manager/Connection.py

@@ -0,0 +1,14 @@
+from ssh_manager.Connection import Connection
+
+
+class Manager:
+    _connections = []
+
+    def __init__(self, connections: [Connection]):
+        self._connections = connections
+
+    def get_connection(self, index: int) -> Connection:
+        return self._connections[index]
+
+    def get_connections(self):
+        return self._connections

ssh_manager/JsonConfigParser.py

@@ -0,0 +1,22 @@
+from ssh_manager.Connection import Connection
+from ssh_manager.config.Window import Window
+
+
+class Config:
+    _connections = []
+    _window = None
+
+    def add_connection(self, connection: Connection):
+        self._connections.append(connection)
+
+    def set_window(self, window: Window):
+        self._window = window
+
+    def get_connections(self):
+        return self._connections
+
+    def get_window(self) -> Window:
+        return self._window
+
+    def set_connections(self, connections):
+        self._connections = connections

ssh_manager/Manager.py

@@ -0,0 +1,12 @@
+class Window:
+    x = 0
+    y = 0
+    width = 0
+    height = 0
+
+    def __init__(self, x: int, y: int, width: int, height: int):
+        self.x = x
+        self.y = y
+        self.width = width
+        self.height = height
+        pass

ssh_manager/__init__.py

@@ -0,0 +1,9 @@
+from abc import ABCMeta, abstractmethod
+
+
+class AbstractApplication:
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def run(self):
+        pass

ssh_manager/config/Config.py

@@ -0,0 +1,11 @@
+from abc import abstractmethod, ABCMeta
+
+from ssh_manager import ConfigurationFile
+
+
+class AbstractConfigParser:
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def parse(self, file: ConfigurationFile):
+        pass

ssh_manager/config/Window.py

@@ -0,0 +1,12 @@
+from abc import ABCMeta, abstractmethod
+
+
+class AbstractConfigurationFile:
+    __metaclass__ = ABCMeta
+
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def get_contents(self):
+        pass

ssh_manager/config/__init__.py

@@ -0,0 +1,100 @@
+from os import system
+
+from gi import require_version
+
+require_version('Gdk', '3.0')
+require_version('Gtk', '3.0')
+
+from gi.repository import Gtk
+
+import Application
+from ssh_manager.Manager import Manager
+from ssh_manager.config.Window import Window
+
+
+class ConnectionListWindow:
+    VERTICAL_MARGIN = 5
+    HORIZONTAL_MARGIN = 2
+    _listbox = None
+    _frame = None
+    _scrollable = None
+    _list_store = Gtk.ListStore(str)
+
+    def __init__(self, manager: Manager, window_config: Window):
+        self._manager = manager
+        self._window_config = window_config
+
+    def show(self):
+        win = Gtk.Window()
+        win.set_size_request(self._window_config.width, self._window_config.height)
+        win.move(self._window_config.x, self._window_config.y)
+        win.set_resizable(False)
+
+        btn_setting = Gtk.Button("Settings")
+        btn_setting.set_margin_right(self.HORIZONTAL_MARGIN)
+        btn_reload = Gtk.Button("Reload")
+
+        btn_box = Gtk.HBox()
+        btn_box.add(btn_setting)
+        btn_box.add(btn_reload)
+
+        self._listbox = Gtk.TreeView(self._list_store)
+        self._listbox.set_headers_visible(False)
+        self._listbox.connect("row-activated", self.row_activated)
+
+        self._scrollable = Gtk.ScrolledWindow()
+        self._scrollable.add(self._listbox)
+        self._fill_listbox()
+
+        self._frame = Gtk.Frame()
+        self._frame.add(self._scrollable)
+        self._frame.set_border_width(1)
+        self._frame.set_margin_bottom(self.VERTICAL_MARGIN)
+
+        vbox = Gtk.VBox()
+        vbox.pack_start(self._frame, 1, 1, 1)
+        vbox.pack_end(btn_box, 0, 0, 0)
+
+        vbox.set_margin_top(self.VERTICAL_MARGIN)
+        vbox.set_margin_bottom(self.VERTICAL_MARGIN)
+        vbox.set_margin_left(self.VERTICAL_MARGIN)
+        vbox.set_margin_right(self.VERTICAL_MARGIN)
+
+        btn_setting.connect("clicked", self.btn_settings_click)
+        btn_reload.connect("clicked", self.btn_reload_click)
+
+        win.add(vbox)
+
+        win.set_title("SshManager GTK")
+        win.connect("delete-event", Gtk.main_quit)
+        win.show_all()
+        Gtk.main()
+
+    # noinspection PyUnusedLocal
+    @staticmethod
+    def btn_settings_click(target):
+        system("xdg-open " + Application.Application.get_config_file_path())
+
+    # noinspection PyUnusedLocal
+    def btn_reload_click(self, target):
+        self._manager = Application.Application.create_default_manager()
+        self._fill_listbox()
+
+    def _fill_listbox(self):
+        self._list_store.clear()
+        connections = self._manager.get_connections()
+        for connection in connections:
+            self._list_store.append([connection.label])
+
+        renderer = Gtk.CellRendererText()
+        column = self._listbox.get_column(0)
+        if not column:
+            column = Gtk.TreeViewColumn(None, renderer, text=0)
+            self._listbox.append_column(column)
+        self._listbox.show_all()
+
+    # noinspection PyUnusedLocal
+    def row_activated(self, target: Gtk.TreeView, path: Gtk.TreePath, column: Gtk.TreeViewColumn):
+        i = path.get_indices()[0]
+        connection = self._manager.get_connection(i)
+        system("gnome-terminal -x ssh {} -p {}".format(connection.host, connection.port))