btwebterminal 2.9.0__tar.gz

btwebterminal-2.9.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: btwebterminal
+Version: 2.9.0
+Summary: Webterminal Component for Bert's Interactive Lesson Loader
+Home-page: https://github.com/berttejeda/bert.webterminal
+Author: Engelbert Tejeda
+Author-email: berttejeda@gmail.com
+Keywords: browser-based,webterminal,xtermjs
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3.7
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: terminado<1.0.0,>=0.12.0
+Requires-Dist: coloredlogs
+Provides-Extra: tests
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: pytest-cov; extra == "tests"
+Requires-Dist: coveralls; extra == "tests"
+Requires-Dist: flake8; extra == "tests"
+Requires-Dist: mypy; extra == "tests"
+
+# Overview
+
+This is the Webterminal agent to be used with various projects I've developed, e.g.
+
+- [bert.dashboard](https://github.com/berttejeda/bert.dashboard)
+- [bert.bill](https://github.com/berttejeda/bert.bill) (superceded by above)
+- [bert.slidev - webterminal addon](https://github.com/berttejeda/bert.slidev)
+
+This agent allows the app's [xtermjs]((https://github.com/xtermjs/xterm.js/)) Webterminal React component to connect \
+to a local bash process on your computer.
+
+You can get this Webterminal agent running either by:
+
+- Running the pre-built docker image:
+  ```shell
+  docker run -it --name webterminal --rm -p 10001:10001 berttejeda/bill-webterminal
+  ```
+- Running `docker-compose up -d` from this project
+- Install btdashboard with `pip install btdashboard` and running `btdashboard`, OR \
+  Cloning the [berttejeda/bert.dashboard](https://github.com/berttejeda/bert.dashboard) project, installing all requirements, and \
+  running `python btdashboard/app.py -aio` \
+  Doing so will launch a local websocket that forwards keystrokes to a bash process on your system
+- Install bertdotbill with `pip install bertdotbill` and running `bill -aio`, OR \
+  Cloning the [bert.bill](https://github.com/berttejeda/bert.bill) project, installing all requirements, and \
+  running `python bertdotbill/app.py -aio` \
+  Doing so will launch a local websocket that forwards keystrokes to a bash process on your system
+
+Either of the commands above will start the websocket and bash process on localhost:10001, \
+but you can change the port if you like.
+
+You can then connect to the agent through the Web UI.
+
+# Architecture
+
+- Utilizes [spyder-terminal](https://github.com/spyder-ide/spyder-terminal) component
+
+# Features
+
+- You can practice the lesson material with your own OS/system
+- Simply **click** on a command, and it will be sent and executed on the underlying shell via web terminal!
+- Default shell is bash (for now)

btwebterminal-2.9.0/README.md

@@ -0,0 +1,41 @@
+# Overview
+
+This is the Webterminal agent to be used with various projects I've developed, e.g.
+
+- [bert.dashboard](https://github.com/berttejeda/bert.dashboard)
+- [bert.bill](https://github.com/berttejeda/bert.bill) (superceded by above)
+- [bert.slidev - webterminal addon](https://github.com/berttejeda/bert.slidev)
+
+This agent allows the app's [xtermjs]((https://github.com/xtermjs/xterm.js/)) Webterminal React component to connect \
+to a local bash process on your computer.
+
+You can get this Webterminal agent running either by:
+
+- Running the pre-built docker image:
+  ```shell
+  docker run -it --name webterminal --rm -p 10001:10001 berttejeda/bill-webterminal
+  ```
+- Running `docker-compose up -d` from this project
+- Install btdashboard with `pip install btdashboard` and running `btdashboard`, OR \
+  Cloning the [berttejeda/bert.dashboard](https://github.com/berttejeda/bert.dashboard) project, installing all requirements, and \
+  running `python btdashboard/app.py -aio` \
+  Doing so will launch a local websocket that forwards keystrokes to a bash process on your system
+- Install bertdotbill with `pip install bertdotbill` and running `bill -aio`, OR \
+  Cloning the [bert.bill](https://github.com/berttejeda/bert.bill) project, installing all requirements, and \
+  running `python bertdotbill/app.py -aio` \
+  Doing so will launch a local websocket that forwards keystrokes to a bash process on your system
+
+Either of the commands above will start the websocket and bash process on localhost:10001, \
+but you can change the port if you like.
+
+You can then connect to the agent through the Web UI.
+
+# Architecture
+
+- Utilizes [spyder-terminal](https://github.com/spyder-ide/spyder-terminal) component
+
+# Features
+
+- You can practice the lesson material with your own OS/system
+- Simply **click** on a command, and it will be sent and executed on the underlying shell via web terminal!
+- Default shell is bash (for now)

btwebterminal-2.9.0/VERSION.txt

@@ -0,0 +1 @@
+2.9.0

btwebterminal-2.9.0/btwebterminal/app.py

@@ -0,0 +1,42 @@
+"""
+Spawn a websocket that handles forking of shell sessions for attachment by the bertdotbill WebTerminal UI element. 
+The code for this was taken from [spyder-terminal](https://github.com/spyder-ide/spyder-terminal).
+"""
+
+import argparse
+import os
+from btwebterminal.webterminal import WebTerminal
+
+def main():
+    """The main entrypoint
+    """
+
+    parser = argparse.ArgumentParser(description="btwebterminal - A websocket-based shell session handler")
+
+    parser.add_argument('--host',
+                        default=os.environ.get('WEBTERMINAL_HOST', '0.0.0.0'),
+                        help='Host to listen on (default: 0.0.0.0 or WEBTERMINAL_HOST env var)')
+
+    parser.add_argument('--port',
+                        type=int,
+                        default=int(os.environ.get('WEBTERMINAL_PORT', 10001)),
+                        help='Port to listen on (default: 10001 or WEBTERMINAL_PORT env var)')
+
+    parser.add_argument('--shell',
+                        default=os.environ.get('WEBTERMINAL_SHELL'),
+                        help='Shell to spawn, can also be set with WEBTERMINAL_SHELL env var')
+
+    parser.add_argument('--debug',
+                        action='store_true',
+                        default=os.environ.get('WEBTERMINAL_DEBUG', 'false').lower() == 'true',
+                        help='Enable debug mode (default: False or WEBTERMINAL_DEBUG=true env var)')
+
+    args = parser.parse_args()
+
+    WebTerminal().start(host=args.host, port=args.port, shell=args.shell, debug=args.debug)
+
+if __name__ == '__main__':
+    main()
+
+
+

btwebterminal-2.9.0/btwebterminal/logger.py

@@ -0,0 +1,41 @@
+import logging
+import logging.handlers
+import coloredlogs
+import os
+import sys
+
+class Logger:
+
+  def __init__(self, **kwargs):
+    env_debug_is_on = os.environ.get('WEBTERMINAL_DEBUG', '').lower() in [
+    't', 'true', '1', 'on', 'y', 'yes']
+    self.debug = kwargs.get('debug', False) or env_debug_is_on
+    self.FORMAT_STR = "%(asctime)s %(name)s [%(levelname)s]: %(message)s"
+    self.formatter = logging.Formatter(
+      self.FORMAT_STR,
+      datefmt='%Y-%m-%d %H:%M:%S'
+    )
+    self.logfile_path = kwargs.get('logfile_path')
+    self.logfile_write_mode = kwargs.get('logfile_write_mode', 'a')
+
+  def init_logger(self, name=None, debug=False):
+    # Setup Logging
+    logger = logging.getLogger(name)
+    # TODO Find a better approach to this hacky method
+    if '--debug' in ' '.join(sys.argv) or self.debug:
+        logging_level = logging.DEBUG
+    else:
+        logging_level = logging.INFO
+    logger.setLevel(logging_level)
+    stdout_handler = logging.StreamHandler(sys.stdout)
+    stdout_handler.setFormatter(self.formatter)
+    logger.addHandler(stdout_handler)
+    if self.logfile_path:
+        # create one handler for print and one for export
+        file_handler = logging.FileHandler(self.logfile_path, self.logfile_write_mode)
+        file_handler.setFormatter(self.formatter)
+        logger.addHandler(file_handler)
+    coloredlogs.install(logger=logger,
+                        fmt=self.FORMAT_STR,
+                        level=logging_level)
+    return logger

btwebterminal-2.9.0/btwebterminal/spyder_terminal/server/__init__.py

@@ -0,0 +1,5 @@
+"""
+This packages contains and implements a simple terminal server.
+
+Creates virtual terminals via pexpect and websockets.
+"""

btwebterminal-2.9.0/btwebterminal/spyder_terminal/server/common.py

@@ -0,0 +1,22 @@
+
+"""General server constants and utillty functions."""
+
+import tornado
+import os.path
+import btwebterminal.spyder_terminal.server.routes as routes
+from btwebterminal.spyder_terminal.server.logic.term_manager import TermManager
+
+
+def create_app(shell, close_future=None, **kwargs):
+    """Create and return a tornado Web Application instance."""
+    debug = kwargs.get('debug')
+    serve_traceback = kwargs.get('serve_traceback')
+    autoreload = kwargs.get('autoreload')
+    settings = {"static_path": os.path.join(
+        os.path.dirname(__file__), "static")}
+    application = tornado.web.Application(routes.gen_routes(close_future),
+                                          debug=debug,
+                                          serve_traceback=serve_traceback,
+                                          autoreload=autoreload, **settings)
+    application.term_manager = TermManager([shell])
+    return application

btwebterminal-2.9.0/btwebterminal/spyder_terminal/server/logic/__init__.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+"""
+logic module.
+
+=========
+Provides:
+    1. Creation and handling of system terminal emulators
+    2. Execution of bash/cmd commands
+
+How to use the documentation
+----------------------------
+Documentation is available in one form: docstrings provided
+with the code
+
+Copyright (c) 2016, Edgar A. Margffoy.
+MIT, see LICENSE for more details.
+"""
+
+from . import term_manager

btwebterminal-2.9.0/btwebterminal/spyder_terminal/server/logic/term_manager.py

@@ -0,0 +1,131 @@
+# -*- coding: utf-8 -*-
+
+"""Term manager."""
+import os
+import time
+import signal
+import hashlib
+import shlex
+import tornado.web
+import tornado.gen
+import tornado.ioloop
+from terminado.management import TermManagerBase, PtyWithClients
+from urllib.parse import unquote
+
+import logging
+LOGGER = logging.getLogger(__name__)
+
+WINDOWS = os.name == 'nt'
+
+
+class PtyReader(PtyWithClients):
+    """Wrapper around PtyWithClients."""
+
+    def resize_to_smallest(self, rows, cols):
+        """Set the terminal size to that of the smallest client dimensions.
+
+        A terminal not using the full space available is much nicer than a
+        terminal trying to use more than the available space, so we keep it
+        sized to the smallest client.
+        """
+        minrows = mincols = 10001
+        if rows is not None and rows < minrows:
+            minrows = rows
+        if cols is not None and cols < mincols:
+            mincols = cols
+
+        if minrows == 10001 or mincols == 10001:
+            return
+
+        rows, cols = self.ptyproc.getwinsize()
+        if (rows, cols) != (minrows, mincols):
+            LOGGER.debug("Resizing PTY to {0}x{1}".format(mincols, minrows))
+            self.ptyproc.setwinsize(minrows, mincols)
+
+
+class TermManager(TermManagerBase):
+    """Wrapper around pexpect to execute local commands."""
+
+    def __init__(self, shell_command, **kwargs):
+        """Create a new terminal handler instance."""
+        super().__init__(shell_command, **kwargs)
+        self.consoles = {}
+
+    def new_terminal(self, **kwargs):
+        """Make a new terminal, return a :class:`PtyReader` instance."""
+        options = self.term_settings.copy()
+        options['shell_command'] = self.shell_command
+        options.update(kwargs)
+        argv = options['shell_command']
+        
+        # Convert list to string for terminado if needed
+        if isinstance(argv, list):
+            # Flatten and ensure all items are strings
+            flat_argv = []
+            for item in argv:
+                if isinstance(item, list):
+                    flat_argv.extend(str(i) for i in item)
+                else:
+                    flat_argv.append(str(item))
+            # Use shlex.quote() for proper shell escaping on Windows
+            argv = ' '.join(shlex.quote(arg) for arg in flat_argv)
+        
+        env = self.make_term_env(**options)
+        cwd = options.get('cwd', None)
+        LOGGER.debug("Spawning new terminal: {0} in {1}".format(argv, cwd))
+        return PtyReader(argv, env, cwd)
+
+    @tornado.gen.coroutine
+    def client_disconnected(self, pid, socket):
+        """Send terminal SIGHUP when client disconnects."""
+        self.log.info("Websocket closed, sending SIGHUP to terminal.")
+        term = self.consoles[pid]
+        term.clients.remove(socket)
+        try:
+            if WINDOWS:
+                term.kill()
+                self.pty_read(term.ptyproc.fd)
+                return
+            term.killpg(signal.SIGHUP)
+        except Exception:
+            pass
+        del self.consoles[pid]
+
+    @tornado.gen.coroutine
+    def create_term(self, rows, cols, cwd=None):
+        """Create a new virtual terminal."""
+        LOGGER.debug("create_term called with rows={0}, cols={1}, cwd={2}".format(rows, cols, cwd))
+        pid = hashlib.md5(str(time.time()).encode('utf-8')).hexdigest()[0:6]
+        # We need to do percent decoding for reading the cwd through a cookie
+        # For further information see spyder-ide/spyder-terminal#225
+        cwd = unquote(cwd)
+        LOGGER.debug("Decoded CWD: {0}".format(cwd))
+        
+        try:
+            pty = self.new_terminal(cwd=cwd, height=rows, width=cols)
+            pty.resize_to_smallest(rows, cols)
+            self.consoles[pid] = pty
+            LOGGER.info("Terminal created with PID {0} for CWD {1}".format(pid, cwd))
+            return pid
+        except Exception as e:
+            LOGGER.error("Error in TermManager.create_term: {0}".format(str(e)), exc_info=True)
+            raise
+
+    @tornado.gen.coroutine
+    def start_term(self, pid, socket):
+        """Start reading a virtual terminal."""
+        term = self.consoles[pid]
+        self.start_reading(term)
+        term.clients.append(socket)
+
+    @tornado.gen.coroutine
+    def execute(self, pid, cmd):
+        """Write characters to terminal."""
+        term = self.consoles[pid]
+        term.ptyproc.write(cmd)
+
+    @tornado.gen.coroutine
+    def resize_term(self, pid, rows, cols):
+        """Resize terminal."""
+        term = self.consoles[pid]
+        term.resize_to_smallest(rows, cols)

btwebterminal-2.9.0/btwebterminal/spyder_terminal/server/rest/__init__.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+"""
+rest module.
+
+=========
+
+Provides:
+    1. Asynchronous execution of JSON services
+
+How to use the documentation
+----------------------------
+Documentation is available in one form: docstrings provided
+with the code
+
+Copyright (c) 2016, Edgar A. Margffoy.
+MIT, see LICENSE for more details.
+"""
+
+from . import term_rest
+term_rest

btwebterminal-2.9.0/btwebterminal/spyder_terminal/server/rest/term_rest.py

@@ -0,0 +1,45 @@
+# -*- coding: iso-8859-15 -*-
+
+"""Main HTTP routes request handlers."""
+
+import logging
+import tornado.web
+import tornado.escape
+from os import getcwd
+
+LOGGER = logging.getLogger(__name__)
+
+
+class MainHandler(tornado.web.RequestHandler):
+    """Handles creation of new terminals."""
+
+    @tornado.gen.coroutine
+    def post(self):
+        """POST verb: Create a new terminal."""
+        LOGGER.debug("Received POST request to create terminal")
+        try:
+            rows = int(self.get_argument('rows', default=23))
+            cols = int(self.get_argument('cols', default=73))
+            cwd = self.get_cookie('cwd', default=getcwd())
+            LOGGER.info('Terminal creation request - CWD: {0}, Size: ({1}, {2})'.format(cwd, cols, rows))
+            
+            LOGGER.debug("Calling term_manager.create_term...")
+            pid = yield self.application.term_manager.create_term(rows, cols, cwd)
+            LOGGER.info('Terminal created successfully with PID: {0}'.format(pid))
+            
+            self.write(pid)
+        except Exception as e:
+            LOGGER.error("Failed to create terminal: {0}".format(str(e)), exc_info=True)
+            self.set_status(500)
+            self.write({"error": "Failed to create terminal", "details": str(e)})
+
+
+class ResizeHandler(tornado.web.RequestHandler):
+    """Handles resizing of terminals."""
+
+    @tornado.gen.coroutine
+    def post(self, pid):
+        """POST verb: Resize a terminal."""
+        rows = int(self.get_argument('rows', default=23))
+        cols = int(self.get_argument('cols', default=73))
+        self.application.term_manager.resize_term(pid, rows, cols)

btwebterminal-2.9.0/btwebterminal/spyder_terminal/server/routes.py

@@ -0,0 +1,49 @@
+# -*- coding: iso-8859-15 -*-
+
+"""
+routes.
+
+======
+
+This module establishes and defines the Web Handlers and Websockets
+that are associated with a specific URL routing name. New routing
+associations must be defined here.
+
+Notes
+-----
+For more information regarding routing URL and valid regular expressions
+visit: http://www.tornadoweb.org/en/stable/guide/structure.html
+"""
+
+import btwebterminal.spyder_terminal.server.web as web
+import btwebterminal.spyder_terminal.server.rest as rest
+import btwebterminal.spyder_terminal.server.websockets as websockets
+
+# Define new rest associations
+REST = [
+    (r"/api/terminals", rest.term_rest.MainHandler),
+    (r"/api/terminals/(.*)/size", rest.term_rest.ResizeHandler)
+]
+
+# Define new websocket routes
+WS = [
+    (r"/terminals/(.*)", websockets.term_ws.MainSocket)
+]
+
+# Define new web rendering route associations
+WEB = [
+    (r'/', web.main_handler.MainHandler)
+]
+
+ROUTES = REST + WS + WEB
+
+
+def gen_routes(close_future):
+    """Return a list of HTML redirection routes."""
+    if close_future is not None:
+        ws = []
+        for route in WS:
+            ws.append((route[0], route[1],
+                       dict(close_future=close_future)))
+        return REST + ws + WEB
+    return ROUTES

btwebterminal-2.9.0/btwebterminal/spyder_terminal/server/tests/__init__.py

@@ -0,0 +1,16 @@
+"""
+tests module.
+
+=========
+
+Provides:
+    1. Websocket and HTTP server methods tests.
+
+How to use the documentation
+----------------------------
+Documentation is available in one form: docstrings provided
+with the code
+
+Copyright (c) 2016, Edgar A. Margffoy.
+MIT, see LICENSE for more details.
+"""

btwebterminal-2.9.0/btwebterminal/spyder_terminal/server/tests/print_size.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python
+
+"""
+Print console size on UNIX and Windows systems.
+
+Taken from: https://gist.github.com/jtriley/1108174
+"""
+
+import os
+import shlex
+import struct
+import platform
+import subprocess
+
+
+def get_terminal_size():
+    """
+    Get width and height of console.
+
+    Works on Linux, OS X, Windows and Cygwin
+    Based on:
+    http://stackoverflow.com/questions/566746/how-to-get-console-window-width-in-python
+    """
+    current_os = platform.system()
+    tuple_xy = None
+    if current_os == 'Windows':
+        tuple_xy = _get_terminal_size_windows()
+        if tuple_xy is None:
+            tuple_xy = _get_terminal_size_tput()
+            # needed for window's python in cygwin's xterm!
+    if current_os in ['Linux', 'Darwin'] or current_os.startswith('CYGWIN'):
+        tuple_xy = _get_terminal_size_linux()
+    if tuple_xy is None:
+        print("default")
+        tuple_xy = (80, 25)      # default value
+    return tuple_xy
+
+
+def _get_terminal_size_windows():
+    try:
+        from ctypes import windll, create_string_buffer
+        # stdin handle is -10
+        # stdout handle is -11
+        # stderr handle is -12
+        h = windll.kernel32.GetStdHandle(-12)
+        csbi = create_string_buffer(22)
+        res = windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
+        if res:
+            (bufx, bufy, curx, cury, wattr,
+             left, top, right, bottom,
+             maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
+            sizex = right - left + 1
+            sizey = bottom - top + 1
+            return sizex, sizey
+    except:
+        pass
+
+
+def _get_terminal_size_tput():
+    """Get terminal width.
+
+    src: http://stackoverflow.com/questions/263890/
+         how-do-i-find-the-width-height-of-a-terminal-window
+    """
+    try:
+        cols = int(subprocess.check_call(shlex.split('tput cols')))
+        rows = int(subprocess.check_call(shlex.split('tput lines')))
+        return (cols, rows)
+    except:
+        pass
+
+
+def _get_terminal_size_linux():
+    def ioctl_GWINSZ(fd):
+        try:
+            import fcntl
+            import termios
+            cr = struct.unpack('hh',
+                               fcntl.ioctl(fd, termios.TIOCGWINSZ, '1234'))
+            return cr
+        except:
+            pass
+    cr = ioctl_GWINSZ(0) or ioctl_GWINSZ(1) or ioctl_GWINSZ(2)
+    if not cr:
+        try:
+            fd = os.open(os.ctermid(), os.O_RDONLY)
+            cr = ioctl_GWINSZ(fd)
+            os.close(fd)
+        except:
+            pass
+    if not cr:
+        try:
+            cr = (os.environ['LINES'], os.environ['COLUMNS'])
+        except:
+            return None
+    return int(cr[1]), int(cr[0])
+
+
+if __name__ == "__main__":
+    print(get_terminal_size())

btwebterminal-2.9.0/btwebterminal/spyder_terminal/server/tests/test_server.py

@@ -0,0 +1,180 @@
+
+"""
+Tornado server-side tests.
+
+Note: This uses tornado.testing unittest style tests
+"""
+
+import os
+import sys
+import os.path as osp
+from urllib.parse import urlencode
+
+
+import pytest
+from flaky import flaky
+from tornado import testing, websocket, gen
+from tornado.concurrent import Future
+from bertdotbill.spyder.utils.programs import find_program
+
+sys.path.append(osp.realpath(osp.dirname(__file__) + "/.."))
+
+from spyder_terminal.server.common import create_app
+
+LOCATION = os.path.realpath(os.path.join(os.getcwd(),
+                                         os.path.dirname(__file__)))
+LOCATION_SLASH = LOCATION.replace('\\', '/')
+
+LINE_END = '\n'
+SHELL = 'bash'
+WINDOWS = os.name == 'nt'
+
+if WINDOWS:
+    LINE_END = '\r\n'
+    SHELL = 'cmd'
+
+
+class TerminalServerTests(testing.AsyncHTTPTestCase):
+    """Main server tests."""
+
+    def get_app(self):
+        """Return HTTP/WS server."""
+        self.close_future = Future()
+        return create_app(SHELL, self.close_future)
+
+    def _mk_connection(self, pid):
+        return websocket.websocket_connect(
+            'ws://127.0.0.1:{0}/terminals/{1}'.format(
+                self.get_http_port(), pid)
+        )
+
+    @gen.coroutine
+    def close(self, ws):
+        """
+        Close a websocket connection and wait for the server side.
+
+        If we don't wait here, there are sometimes leak warnings in the
+        tests.
+        """
+        ws.close()
+        yield self.close_future
+
+    @testing.gen_test
+    def test_main_get(self):
+        """Test if HTML source is rendered."""
+        response = yield self.http_client.fetch(
+            self.get_url('/'),
+            method="GET"
+        )
+        self.assertEqual(response.code, 200)
+
+    @testing.gen_test
+    def test_main_post(self):
+        """Test that POST requests to root are forbidden."""
+        try:
+            yield self.http_client.fetch(
+                self.get_url('/'),
+                method="POST",
+                body=''
+            )
+        except Exception:
+            pass
+
+    @testing.gen_test
+    def test_create_terminal(self):
+        """Test terminal creation."""
+        data = {'rows': '25', 'cols': '80'}
+        response = yield self.http_client.fetch(
+            self.get_url('/api/terminals'),
+            method="POST",
+            body=urlencode(data)
+        )
+        self.assertEqual(response.code, 200)
+
+    @flaky(max_runs=3)
+    @testing.gen_test
+    def test_terminal_communication(self):
+        """Test terminal creation."""
+        data = {'rows': '25', 'cols': '100'}
+        response = yield self.http_client.fetch(
+            self.get_url('/api/terminals'),
+            method="POST",
+            body=urlencode(data)
+        )
+        pid = response.body.decode('utf-8')
+        sock = yield self._mk_connection(pid)
+        msg = yield sock.read_message()
+        print(msg)
+        test_msg = 'pwd'
+        sock.write_message(' ' + test_msg)
+        msg = ''
+        while test_msg not in msg:
+            msg += yield sock.read_message()
+            print(msg)
+            msg = ''.join(msg.rstrip())
+        self.assertTrue(test_msg in msg)
+        yield self.close(sock)
+
+    @testing.gen_test
+    def test_terminal_closing(self):
+        """Test terminal destruction."""
+        data = {'rows': '25', 'cols': '80'}
+        response = yield self.http_client.fetch(
+            self.get_url('/api/terminals'),
+            method="POST",
+            body=urlencode(data)
+        )
+        pid = response.body.decode('utf-8')
+        sock = yield self._mk_connection(pid)
+        _ = yield sock.read_message()
+        yield self.close(sock)
+        try:
+            sock.write_message(' This shall not work')
+        except AttributeError:
+            pass
+        yield self.close(sock)
+
+    @flaky(max_runs=3)
+    @pytest.mark.timeout(10)
+    @testing.gen_test
+    @pytest.mark.skipif(os.name == 'nt', reason="Doesn't work on Windows")
+    def test_terminal_resize(self):
+        """Test terminal resizing."""
+        data = {'rows': '25', 'cols': '80'}
+        response = yield self.http_client.fetch(
+            self.get_url('/api/terminals'),
+            method="POST",
+            body=urlencode(data)
+        )
+
+        pid = response.body.decode('utf-8')
+        sock = yield self._mk_connection(pid)
+        _ = yield sock.read_message()
+
+        data = {'rows': '23', 'cols': '73'}
+        response = yield self.http_client.fetch(
+            self.get_url('/api/terminals/{0}/size'.format(pid)),
+            method="POST",
+            body=urlencode(data)
+        )
+
+        sock.write_message('cd {0}{1}'.format(LOCATION_SLASH, LINE_END))
+
+        # Use the current python interpreter to execute print_size.py if it
+        # can be determined by sys.executable. Otherwise just hope that there
+        # is a `python` in the shell's path which works with the script.
+        python_bin = sys.executable or "python"
+        python_exec = python_bin + ' print_size.py' + LINE_END
+        sock.write_message(python_exec)
+
+        expected_size = '(73, 23)'
+        msg = ''
+        fail_retry = 50
+        tries = 0
+        while expected_size not in msg:
+            if tries == fail_retry:
+                break
+            msg = yield sock.read_message()
+            tries += 1
+        self.assertIn(expected_size, msg)
+        yield self.close(sock)

btwebterminal-2.9.0/btwebterminal/spyder_terminal/server/web/__init__.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+"""
+web module.
+
+=========
+
+Provides:
+    1. Asynchronous execution of Web Rendering
+
+How to use the documentation
+----------------------------
+Documentation is available in one form: docstrings provided
+with the code
+
+Copyright (c) 2016, Edgar A. Margffoy.
+MIT, see LICENSE for more details.
+"""
+
+from . import main_handler

btwebterminal-2.9.0/btwebterminal/spyder_terminal/server/web/main_handler.py

@@ -0,0 +1,29 @@
+# -*- coding: iso-8859-15 -*-
+
+"""Basic static index.html HTTP handler."""
+import tornado.web
+import tornado.escape
+from os import getcwd
+from urllib.parse import quote
+
+
+class MainHandler(tornado.web.RequestHandler):
+    """Handles index request."""
+
+    def initialize(self, db=None):
+        """Stump initialization function."""
+        self.db = db
+
+    @tornado.gen.coroutine
+    def get(self):
+        """Get static index.html page."""
+        cwd = self.get_argument('path', getcwd())
+        # We need to do percent encoding for sending the cwd through a cookie
+        # For further information see spyder-ide/spyder-terminal#225
+        self.set_cookie('cwd', quote(cwd))
+        self.render('../static/build/index.html')
+
+    @tornado.gen.coroutine
+    def post(self):
+        """POST verb: Forbidden."""
+        self.set_status(403)

btwebterminal-2.9.0/btwebterminal/spyder_terminal/server/websockets/__init__.py

@@ -0,0 +1,18 @@
+"""
+web module.
+
+=========
+
+Provides:
+    1. Asynchronous execution of Websockets
+
+How to use the documentation
+----------------------------
+Documentation is available in one form: docstrings provided
+with the code
+
+Copyright (c) 2016, Edgar A. Margffoy.
+MIT, see LICENSE for more details.
+"""
+
+from . import term_ws

btwebterminal-2.9.0/btwebterminal/spyder_terminal/server/websockets/term_ws.py

@@ -0,0 +1,51 @@
+# -*- coding: iso-8859-15 -*-
+
+"""Websocket handling class."""
+
+import logging
+import tornado.escape
+import tornado.websocket
+
+LOGGER = logging.getLogger(__name__)
+
+
+class MainSocket(tornado.websocket.WebSocketHandler):
+    """Handles long polling communication between xterm.js and server."""
+
+    def check_origin(self, origin):
+        return True
+        
+    def initialize(self, close_future=None):
+        """Base class initialization."""
+        self.close_future = close_future
+
+    def open(self, pid):
+        """Open a Websocket associated to a console."""
+        LOGGER.info("WebSocket opened: {0}".format(pid))
+        self.pid = pid
+        self.application.term_manager.start_term(pid, self)
+        LOGGER.info("TTY On!")
+
+    def on_preclose(self):
+        """Close console communication."""
+        LOGGER.info('Wassup!')
+
+    def on_close(self):
+        """Close console communication."""
+        LOGGER.info('TTY Off!')
+        LOGGER.info("WebSocket closed: {0}".format(self.pid))
+        self.application.term_manager.client_disconnected(self.pid, self)
+        if self.close_future is not None:
+            self.close_future.set_result(("Done!"))
+
+    def on_message(self, message):
+        """Execute a command on console."""
+        self.application.term_manager.execute(self.pid, message)
+
+    def on_pty_read(self, text):
+        """Read data from pty; send to frontend."""
+        self.write_message(text)
+
+    def on_pty_died(self):
+        """Close websocket if terminal was closed externally."""
+        self.close()

btwebterminal-2.9.0/btwebterminal/webterminal.py

@@ -0,0 +1,58 @@
+import os
+import tornado.web
+import tornado.ioloop
+from btwebterminal.spyder_terminal.server.common import create_app
+from pathlib import Path
+
+from btwebterminal.logger import Logger
+logger = Logger().init_logger(None)
+
+class WebTerminal:
+
+    def __init__(self):
+      pass
+
+    def _get_default_shell(self):
+        """Get the appropriate shell command for the OS."""
+        if os.name == 'nt':  # Windows
+            # Try Git Bash first
+            localappdata = os.environ.get('LOCALAPPDATA', '')
+            git_bash_paths = [
+                (Path(localappdata) / "Programs\\Git\\git-cmd.exe"),
+                Path("C:\\Program Files\\Git\\git-cmd.exe"),
+                Path("C:\\Program Files (x86)\\Git\\git-cmd.exe"),
+            ]
+            for git_bash in git_bash_paths:
+                if git_bash.exists():
+                    return [git_bash.as_posix(), "--no-cd", "--command=usr/bin/bash.exe", "-l", "-i"]
+            # Fallback to cmd.exe
+            return ["cmd.exe"]
+        else:
+            # Unix-like systems
+            return ["/bin/bash"]      
+
+    def start(self, host, port, shell=None, debug=False):
+        clr = 'cls'
+        webterminal_shell_name = 'bash'
+        logger.info(f'Server is now at: {host}:{port}')
+        logger.info(f'Shell: {webterminal_shell_name}')
+        
+        # Use provided shell or detect default
+        if shell is None:
+            shell = self._get_default_shell()
+
+        application = create_app(shell,
+                                 debug=debug,
+                                 serve_traceback=debug,
+                                 autoreload=debug)
+        ioloop = tornado.ioloop.IOLoop.instance()
+        application.listen(port, address=host)
+        try:
+            ioloop.start()
+        except KeyboardInterrupt:
+            pass
+        finally:
+            logger.info("Closing server...\n")
+            ioloop.run_sync(application.term_manager.shutdown)
+            tornado.ioloop.IOLoop.instance().stop()
+

btwebterminal-2.9.0/btwebterminal.egg-info/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: btwebterminal
+Version: 2.9.0
+Summary: Webterminal Component for Bert's Interactive Lesson Loader
+Home-page: https://github.com/berttejeda/bert.webterminal
+Author: Engelbert Tejeda
+Author-email: berttejeda@gmail.com
+Keywords: browser-based,webterminal,xtermjs
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3.7
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: terminado<1.0.0,>=0.12.0
+Requires-Dist: coloredlogs
+Provides-Extra: tests
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: pytest-cov; extra == "tests"
+Requires-Dist: coveralls; extra == "tests"
+Requires-Dist: flake8; extra == "tests"
+Requires-Dist: mypy; extra == "tests"
+
+# Overview
+
+This is the Webterminal agent to be used with various projects I've developed, e.g.
+
+- [bert.dashboard](https://github.com/berttejeda/bert.dashboard)
+- [bert.bill](https://github.com/berttejeda/bert.bill) (superceded by above)
+- [bert.slidev - webterminal addon](https://github.com/berttejeda/bert.slidev)
+
+This agent allows the app's [xtermjs]((https://github.com/xtermjs/xterm.js/)) Webterminal React component to connect \
+to a local bash process on your computer.
+
+You can get this Webterminal agent running either by:
+
+- Running the pre-built docker image:
+  ```shell
+  docker run -it --name webterminal --rm -p 10001:10001 berttejeda/bill-webterminal
+  ```
+- Running `docker-compose up -d` from this project
+- Install btdashboard with `pip install btdashboard` and running `btdashboard`, OR \
+  Cloning the [berttejeda/bert.dashboard](https://github.com/berttejeda/bert.dashboard) project, installing all requirements, and \
+  running `python btdashboard/app.py -aio` \
+  Doing so will launch a local websocket that forwards keystrokes to a bash process on your system
+- Install bertdotbill with `pip install bertdotbill` and running `bill -aio`, OR \
+  Cloning the [bert.bill](https://github.com/berttejeda/bert.bill) project, installing all requirements, and \
+  running `python bertdotbill/app.py -aio` \
+  Doing so will launch a local websocket that forwards keystrokes to a bash process on your system
+
+Either of the commands above will start the websocket and bash process on localhost:10001, \
+but you can change the port if you like.
+
+You can then connect to the agent through the Web UI.
+
+# Architecture
+
+- Utilizes [spyder-terminal](https://github.com/spyder-ide/spyder-terminal) component
+
+# Features
+
+- You can practice the lesson material with your own OS/system
+- Simply **click** on a command, and it will be sent and executed on the underlying shell via web terminal!
+- Default shell is bash (for now)

btwebterminal-2.9.0/btwebterminal.egg-info/SOURCES.txt

@@ -0,0 +1,30 @@
+README.md
+VERSION.txt
+setup.cfg
+setup.py
+btwebterminal/__init__.py
+btwebterminal/app.py
+btwebterminal/logger.py
+btwebterminal/webterminal.py
+btwebterminal.egg-info/PKG-INFO
+btwebterminal.egg-info/SOURCES.txt
+btwebterminal.egg-info/dependency_links.txt
+btwebterminal.egg-info/entry_points.txt
+btwebterminal.egg-info/not-zip-safe
+btwebterminal.egg-info/requires.txt
+btwebterminal.egg-info/top_level.txt
+btwebterminal/spyder_terminal/__init__.py
+btwebterminal/spyder_terminal/server/__init__.py
+btwebterminal/spyder_terminal/server/common.py
+btwebterminal/spyder_terminal/server/routes.py
+btwebterminal/spyder_terminal/server/logic/__init__.py
+btwebterminal/spyder_terminal/server/logic/term_manager.py
+btwebterminal/spyder_terminal/server/rest/__init__.py
+btwebterminal/spyder_terminal/server/rest/term_rest.py
+btwebterminal/spyder_terminal/server/tests/__init__.py
+btwebterminal/spyder_terminal/server/tests/print_size.py
+btwebterminal/spyder_terminal/server/tests/test_server.py
+btwebterminal/spyder_terminal/server/web/__init__.py
+btwebterminal/spyder_terminal/server/web/main_handler.py
+btwebterminal/spyder_terminal/server/websockets/__init__.py
+btwebterminal/spyder_terminal/server/websockets/term_ws.py

btwebterminal-2.9.0/btwebterminal.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

btwebterminal-2.9.0/btwebterminal.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bt-webterminal = btwebterminal.app:main

btwebterminal-2.9.0/btwebterminal.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

btwebterminal-2.9.0/btwebterminal.egg-info/requires.txt

@@ -0,0 +1,9 @@
+terminado<1.0.0,>=0.12.0
+coloredlogs
+
+[tests]
+pytest
+pytest-cov
+coveralls
+flake8
+mypy

btwebterminal-2.9.0/btwebterminal.egg-info/top_level.txt

@@ -0,0 +1 @@
+btwebterminal

btwebterminal-2.9.0/setup.cfg

@@ -0,0 +1,61 @@
+[check-manifest]
+ignore = 
+	Dockerfile
+	entrypoint.sh
+	openssl.cnf
+
+[metadata]
+name = btwebterminal
+author = Engelbert Tejeda
+author_email = berttejeda@gmail.com
+description = Webterminal Component for Bert's Interactive Lesson Loader
+version = file: VERSION.txt
+url = https://github.com/berttejeda/bert.webterminal
+keywords = 
+	browser-based
+	webterminal
+	xtermjs
+classifiers = 
+	Development Status :: 3 - Alpha
+	Intended Audience :: Developers
+	Intended Audience :: Information Technology
+	License :: OSI Approved :: MIT License
+	Natural Language :: English
+	Programming Language :: Python :: 3.7
+long_description = file: README.md
+long_description_content_type = text/markdown
+license_files = 
+	LICENSE.txt
+
+[options]
+include_package_data = true
+python_requires = >= 3.7
+setup_requires = 
+	setuptools >= 40.6
+	pip >= 10
+	wheel >= 0.31
+packages = find:
+zip_safe = False
+scripts = 
+install_requires = 
+	terminado>=0.12.0,<1.0.0
+	coloredlogs
+
+[options.extras_require]
+tests = 
+	pytest
+	pytest-cov
+	coveralls
+	flake8
+	mypy
+
+[options.entry_points]
+console_scripts = 
+	bt-webterminal=btwebterminal.app:main
+
+[options.data_files]
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

btwebterminal-2.9.0/setup.py

@@ -0,0 +1,33 @@
+import configparser as ConfigParser
+import os
+from setuptools import setup
+import sysconfig
+import sys
+
+gui_dirname = 'bill.gui'
+
+cfg = ConfigParser.ConfigParser()
+cfg.read('setup.cfg')
+my_package_name = cfg.get('metadata', 'name')
+
+if sys.platform == 'win32':
+  site_packages_path = 'scripts'
+else:
+  site_packages_path = 'bin'
+
+data_files_path = site_packages_path
+
+def tree(src):
+  result = []
+  data_file_path = os.path.join(data_files_path, src)
+  for root, dirs, files in os.walk(src):
+    for file in files:
+      if os.path.sep in root:
+          sub_root = root.split(os.path.sep, 1)[-1]
+          file = os.path.join(sub_root, file)
+      result.append(os.path.join(src, file))
+  return [(data_file_path, result)]
+
+DATA_FILES = tree(gui_dirname)
+
+setup(data_files=DATA_FILES)