pywinpty 3.0.3__cp313-cp313t-win_arm64.whl

pywinpty-3.0.3.dist-info/METADATA

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: pywinpty
+Version: 3.0.3
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: Free Threading
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Terminals
+Classifier: Topic :: Terminals :: Terminal Emulators/X Terminals
+Classifier: Programming Language :: Rust
+License-File: LICENSE.txt
+Summary: Pseudo terminal support for Windows from Python.
+Keywords: PTY,Windows,pseudo-terminal,PyO3
+Author: Edgar Margffoy
+Author-email: andfoy@gmail.com
+Maintainer-email: Edgar Margffoy <andfoy@gmail.com>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Changelog, https://github.com/andfoy/pywinpty/blob/main/CHANGELOG.md
+Project-URL: Repository, https://github.com/andfoy/pywinpty
+
+# PyWinpty: Pseudoterminals for Windows in Python
+
+[![Project License - MIT](https://img.shields.io/pypi/l/pywinpty.svg)](./LICENSE.txt)
+[![pypi version](https://img.shields.io/pypi/v/pywinpty.svg)](https://pypi.org/project/pywinpty/)
+[![conda version](https://img.shields.io/conda/vn/conda-forge/pywinpty.svg)](https://www.anaconda.com/download/)
+[![download count](https://img.shields.io/conda/dn/conda-forge/pywinpty.svg)](https://www.anaconda.com/download/)
+[![Downloads](https://pepy.tech/badge/pywinpty)](https://pepy.tech/project/pywinpty)
+[![PyPI status](https://img.shields.io/pypi/status/pywinpty.svg)](https://github.com/spyder-ide/pywinpty)
+[![Windows tests](https://github.com/andfoy/pywinpty/actions/workflows/windows_build.yml/badge.svg)](https://github.com/andfoy/pywinpty/actions/workflows/windows_build.yml)
+
+*Copyright © 2017–2022 Spyder Project Contributors*
+*Copyright © 2022– Edgar Andrés Margffoy Tuay*
+
+
+## Overview
+
+PyWinpty allows creating and communicating with Windows processes that receive input and print outputs via console input and output pipes. PyWinpty supports both the native [ConPTY](https://devblogs.microsoft.com/commandline/windows-command-line-introducing-the-windows-pseudo-console-conpty/) interface and the previous, fallback [winpty](https://github.com/rprichard/winpty) library.
+
+
+## Dependencies
+To compile pywinpty sources, you must have [Rust](https://rustup.rs/) installed.
+Optionally, you can also have Winpty's C header and library files available on your include path.
+
+
+## Installation
+You can install this library by using conda or pip package managers, as it follows:
+
+Using conda (Recommended):
+```bash
+conda install pywinpty
+```
+
+Using pip:
+```bash
+pip install pywinpty
+```
+
+## Building from source
+
+To build from sources, you will require both a working stable or nightly Rust toolchain with
+target `x86_64-pc-windows-msvc`, which can be installed using [rustup](https://rustup.rs/).
+
+Optionally, this library can be linked against winpty library, which you can install using conda-forge:
+
+```batch
+conda install winpty -c conda-forge
+```
+
+If you don't want to use conda, you will need to have the winpty binaries and headers available on your PATH.
+
+Finally, pywinpty uses [Maturin](https://github.com/PyO3/maturin) as the build backend, which can be installed using `pip`:
+
+```batch
+pip install maturin
+```
+
+To test your compilation environment settings, you can build pywinpty sources locally, by
+executing:
+
+```bash
+maturin develop
+```
+
+This package depends on the following Rust crates:
+
+* [PyO3](https://github.com/PyO3/pyo3): Library used to produce Python bindings from Rust code.
+* [WinPTY-rs](https://github.com/andfoy/winpty-rs): Create and spawn processes inside a pseudoterminal in Windows from Rust.
+* [Maturin](https://github.com/PyO3/maturin): Build system to build and publish Rust-based Python packages.
+
+## Package usage
+Pywinpty offers a single python wrapper around winpty library functions.
+This implies that using a single object (``winpty.PTY``) it is possible to access to all functionality, as it follows:
+
+```python
+# High level usage using `spawn`
+from winpty import PtyProcess
+
+proc = PtyProcess.spawn('python')
+proc.write('print("hello, world!")\r\n')
+proc.write('exit()\r\n')
+while proc.isalive():
+	print(proc.readline())
+
+# Low level usage using the raw `PTY` object
+from winpty import PTY
+
+# Start a new winpty-agent process of size (cols, rows)
+cols, rows = 80, 25
+process = PTY(cols, rows)
+
+# Spawn a new console process, e.g., CMD
+process.spawn(br'C:\windows\system32\cmd.exe')
+
+# Read console output (Unicode)
+process.read()
+
+# Write input to console (Unicode)
+process.write(b'Text')
+
+# Resize console size
+new_cols, new_rows = 90, 30
+process.set_size(new_cols, new_rows)
+
+# Know if the process is alive
+alive = process.isalive()
+
+# End winpty-agent process
+del process
+```
+
+## Running tests
+We use pytest to run tests as it follows (after calling ``maturin develop``), the test suite depends
+on pytest-lazy-fixture, which can be installed via pip:
+
+```batch
+pip install pytest pytest-lazy-fixture flaky
+```
+
+All the tests can be executed using the following command
+
+```bash
+python runtests.py
+```
+
+
+## Changelog
+Visit our [CHANGELOG](CHANGELOG.md) file to learn more about our new features and improvements.
+
+
+## Contribution guidelines
+We follow PEP8 and PEP257 for pure python packages and Rust to compile extensions. We use MyPy type annotations for all functions and classes declared on this package. Feel free to send a PR or create an issue if you have any problem/question.
+
+
+## Security contact information
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.
+

pywinpty-3.0.3.dist-info/RECORD

@@ -0,0 +1,12 @@
+pywinpty-3.0.3.dist-info\METADATA,sha256=poyhYBPHwV2raTRVtLtL-_ogd-kuEP83l1cjQbN4bGA,5890
+pywinpty-3.0.3.dist-info\WHEEL,sha256=HzMhMZ5m0Z89vUkS-V0VF24Ien1b8bNjE3scHQmaZDQ,98
+pywinpty-3.0.3.dist-info\licenses\LICENSE.txt,sha256=-HjUdn-a0uQ9MIPvoAIBsADOk32e6GJuALpccqrJUeI,1088
+winpty\__init__.py,sha256=laTi9sLjCLycyaQYO3wMvhZNIK2vh_pOvGTJT2Od4Qs,402
+winpty\enums.py,sha256=KAm7XJFPk7nMWwUJxvYHlql92cr6y-Y24IHK3fc0JDU,1860
+winpty\ptyprocess.py,sha256=hucCVfBridHRc4IPiEFrEkdFhU-UKSQbyZUa97EceDc,12209
+winpty\tests\__init__.py,sha256=fzb9cDnPt2R3b_rWh6sqDgIbiQOZtBlfsV1aq-ULT2Q,53
+winpty\tests\test_pty.py,sha256=AXujQybXhKr0t0UKpNBSqeAfsm4fHoU_ognbiocBF5I,3947
+winpty\tests\test_ptyprocess.py,sha256=MeGp_P-zkseEp0iXciWh9Fa548hYGdvlcaHy_WNEwXo,6112
+winpty\winpty.cp313t-win_arm64.pyd,sha256=xgirsSlLAUkOXe6FBnNq6FL5j-WpCBQhxEiz57EuuMY,523776
+winpty\winpty.pyi,sha256=-VenowCvy8tjIZUCvvb5VZw5R1c6ATXEUfsiEyIZwjE,1176
+pywinpty-3.0.3.dist-info\RECORD,,

pywinpty-3.0.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp313-cp313t-win_arm64

pywinpty-3.0.3.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Spyder IDE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

winpty/__init__.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+"""
+Pywinpty
+========
+This package provides low and high level APIs to create
+pseudo terminals in Windows.
+"""
+
+# Local imports
+from .winpty import PTY, WinptyError, __version__
+from .ptyprocess import PtyProcess
+from .enums import Backend, Encoding, MouseMode, AgentConfig
+
+
+PTY
+PtyProcess
+Backend
+Encoding
+MouseMode
+AgentConfig
+WinptyError
+
+__version__

winpty/enums.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+
+"""General constants used to spawn a PTY."""
+
+
+class Backend:
+    """Available PTY backends."""
+    ConPTY = 0
+    WinPTY = 1
+
+
+class Encoding:
+    """Available byte encodings to communicate with a PTY."""
+    UTF8 = 'utf-8'
+    UTF16 = 'utf-16'
+
+
+class MouseMode:
+    """Mouse capture settings for the winpty backend."""
+
+    # QuickEdit mode is initially disabled, and the agent does not send mouse
+    # mode sequences to the terminal.  If it receives mouse input, though, it
+    # still writes MOUSE_EVENT_RECORD values into CONIN.
+    WINPTY_MOUSE_MODE_NONE = 0
+
+    # QuickEdit mode is initially enabled.  As CONIN enters or leaves mouse
+    # input mode (i.e. where ENABLE_MOUSE_INPUT is on and
+    # ENABLE_QUICK_EDIT_MODE is off), the agent enables or disables mouse
+    # input on the terminal.
+    WINPTY_MOUSE_MODE_AUTO = 1
+
+    # QuickEdit mode is initially disabled, and the agent enables the
+    # terminal's mouse input mode.  It does not disable terminal
+    # mouse mode (until exit).
+    WINPTY_MOUSE_MODE_FORCE = 2
+
+
+class AgentConfig:
+    """General configuration settings for the winpty backend."""
+
+    # Create a new screen buffer (connected to the "conerr" terminal pipe) and
+    # pass it to child processes as the STDERR handle.  This flag also prevents
+    # the agent from reopening CONOUT$ when it polls -- regardless of whether
+    # the active screen buffer changes, winpty continues to monitor the
+    # original primary screen buffer.
+    WINPTY_FLAG_CONERR = 0x1
+
+    # Don't output escape sequences.
+    WINPTY_FLAG_PLAIN_OUTPUT = 0x2
+
+    # Do output color escape sequences.  These escapes are output by default,
+    # but are suppressed with WINPTY_FLAG_PLAIN_OUTPUT.
+    # Use this flag to re-enable them.
+    WINPTY_FLAG_COLOR_ESCAPES = 0x4

winpty/ptyprocess.py

@@ -0,0 +1,372 @@
+# -*- coding: utf-8 -*-
+
+# Standard library imports
+import os
+import shlex
+import signal
+import socket
+import subprocess
+import threading
+import time
+from shutil import which
+
+# Local imports
+from .winpty import PTY
+
+
+class PtyProcess(object):
+    """This class represents a process running in a pseudoterminal.
+
+    The main constructor is the :meth:`spawn` classmethod.
+    """
+
+    def __init__(self, pty):
+        assert isinstance(pty, PTY)
+        self.pty = pty
+        self.pid = pty.pid
+        # self.fd = pty.fd
+        self.argv = None
+        self.env = None
+        self.launch_dir = None
+
+        self.read_blocking = bool(int(os.environ.get('PYWINPTY_BLOCK', 1)))
+        self.closed = False
+        self.flag_eof = False
+
+        # Used by terminate() to give kernel time to update process status.
+        # Time in seconds.
+        self.delayafterterminate = 0.1
+        # Used by close() to give kernel time to update process status.
+        # Time in seconds.
+        self.delayafterclose = 0.1
+
+        # Set up our file reader sockets.
+        self._server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self._server.bind(("127.0.0.1", 0))
+        address = self._server.getsockname()
+        self._server.listen(1)
+
+        # Read from the pty in a thread.
+        self._thread = threading.Thread(target=_read_in_thread,
+            args=(address, self.pty, self.read_blocking))
+        self._thread.daemon = True
+        self._thread.start()
+
+        self.fileobj, _ = self._server.accept()
+        self.fd = self.fileobj.fileno()
+
+    @classmethod
+    def spawn(cls, argv, cwd=None, env=None, dimensions=(24, 80),
+              backend=None):
+        """Start the given command in a child process in a pseudo terminal.
+
+        This does all the setting up the pty, and returns an instance of
+        PtyProcess.
+
+        Dimensions of the psuedoterminal used for the subprocess can be
+        specified as a tuple (rows, cols), or the default (24, 80) will be
+        used.
+        """
+        if isinstance(argv, str):
+            argv = shlex.split(argv, posix=False)
+
+        if not isinstance(argv, (list, tuple)):
+            raise TypeError("Expected a list or tuple for argv, got %r" % argv)
+
+        # Shallow copy of argv so we can modify it
+        _argv: list[str] = list(argv[:])
+        command = _argv[0]
+        env = env or os.environ
+
+        path = env.get('PATH', os.defpath)
+        command_with_path = which(command, path=path)
+        if command_with_path is None:
+            raise FileNotFoundError(
+                'The command was not found or was not ' +
+                'executable: %s.' % command
+            )
+        command = command_with_path
+        _argv[0] = command
+        cmdline = ' ' + subprocess.list2cmdline(_argv[1:])
+        cwd = cwd or os.getcwd()
+
+        backend = backend or os.environ.get('PYWINPTY_BACKEND', None)
+        backend = int(backend) if backend is not None else backend
+
+        proc = PTY(dimensions[1], dimensions[0],
+                   backend=backend)
+
+        # Create the environment string.
+        envStrs = []
+        for (key, value) in env.items():
+            envStrs.append('%s=%s' % (key, value))
+        env = '\0'.join(envStrs) + '\0'
+
+        # command = bytes(command, encoding)
+        # cwd = bytes(cwd, encoding)
+        # cmdline = bytes(cmdline, encoding)
+        # env = bytes(env, encoding)
+
+        if len(_argv) == 1:
+            proc.spawn(command, cwd=cwd, env=env)
+        else:
+            proc.spawn(command, cwd=cwd, env=env, cmdline=cmdline)
+
+        inst = cls(proc)
+        inst._winsize = dimensions
+
+        # Set some informational attributes
+        inst.argv = _argv
+        if env is not None:
+            inst.env = env
+        if cwd is not None:
+            inst.launch_dir = cwd
+
+        return inst
+
+    @property
+    def exitstatus(self):
+        """The exit status of the process.
+        """
+        return self.pty.get_exitstatus()
+
+    def fileno(self):
+        """This returns the file descriptor of the pty for the child.
+        """
+        return self.fd
+
+    def close(self, force=False):
+        """This closes the connection with the child application. Note that
+        calling close() more than once is valid. This emulates standard Python
+        behavior with files. Set force to True if you want to make sure that
+        the child is terminated (SIGKILL is sent if the child ignores
+        SIGINT)."""
+        if not self.closed:
+            self.fileobj.close()
+            self._server.close()
+            # Give kernel time to update process status.
+            time.sleep(self.delayafterclose)
+            if self.isalive():
+                if not self.terminate(force):
+                    raise IOError('Could not terminate the child.')
+            self.fd = -1
+            self.closed = True
+            # del self.pty
+
+    def __del__(self):
+        """This makes sure that no system resources are left open. Python only
+        garbage collects Python objects. OS file descriptors are not Python
+        objects, so they must be handled explicitly. If the child file
+        descriptor was opened outside of this class (passed to the constructor)
+        then this does not close it.
+        """
+        # It is possible for __del__ methods to execute during the
+        # teardown of the Python VM itself. Thus self.close() may
+        # trigger an exception because os.close may be None.
+        try:
+            self.close()
+        except Exception:
+            pass
+
+    def flush(self):
+        """This does nothing. It is here to support the interface for a
+        File-like object. """
+        pass
+
+    def isatty(self):
+        """This returns True if the file descriptor is open and connected to a
+        tty(-like) device, else False."""
+        return self.isalive()
+
+    def read(self, size=1024):
+        """Read and return at most ``size`` characters from the pty.
+
+        Can block if there is nothing to read. Raises :exc:`EOFError` if the
+        terminal was closed.
+        """
+        # try:
+        #     data = self.pty.read(size, blocking=self.read_blocking)
+        # except Exception as e:
+        #     if "EOF" in str(e):
+        #         raise EOFError(e) from e
+        # return data
+        data = self.fileobj.recv(size)
+        if not data:
+            self.flag_eof = True
+            raise EOFError('Pty is closed')
+
+        if data == b'0011Ignore':
+            data = b''
+
+        err = True
+        while err and data:
+            try:
+                data.decode('utf-8')
+                err = False
+            except UnicodeDecodeError:
+                data += self.fileobj.recv(1)
+        return data.decode('utf-8')
+
+    def readline(self):
+        """Read one line from the pseudoterminal as bytes.
+
+        Can block if there is nothing to read. Raises :exc:`EOFError` if the
+        terminal was closed.
+        """
+        buf = []
+        while 1:
+            try:
+                ch = self.read(1)
+            except EOFError:
+                return ''.join(buf)
+            buf.append(ch)
+            if ch == '\n':
+                return ''.join(buf)
+
+    def write(self, s):
+        """Write the string ``s`` to the pseudoterminal.
+
+        Returns the number of bytes written.
+        """
+        if not self.pty.isalive():
+            raise EOFError('Pty is closed')
+
+        nbytes = self.pty.write(s)
+        return nbytes
+
+    def terminate(self, force=False):
+        """This forces a child process to terminate."""
+        if not self.isalive():
+            return True
+        self.kill(signal.SIGINT)
+        try:
+            self.pty.cancel_io()
+        except Exception:
+            pass
+        time.sleep(self.delayafterterminate)
+        if not self.isalive():
+            return True
+        if force:
+            self.kill(signal.SIGTERM)
+            time.sleep(self.delayafterterminate)
+            if not self.isalive():
+                return True
+            else:
+                return False
+
+    def wait(self):
+        """This waits until the child exits. This is a blocking call. This will
+        not read any data from the child.
+        """
+        while self.isalive():
+            time.sleep(0.1)
+        return self.exitstatus
+
+    def isalive(self):
+        """This tests if the child process is running or not. This is
+        non-blocking. If the child was terminated then this will read the
+        exitstatus or signalstatus of the child. This returns True if the child
+        process appears to be running or False if not.
+        """
+        alive = self.pty.isalive()
+        self.closed = not alive
+        return alive
+
+    def kill(self, sig):
+        """Kill the process with the given signal.
+        """
+        if self.pid is None:
+            return
+        os.kill(self.pid, sig)
+
+    def sendcontrol(self, char):
+        '''Helper method that wraps send() with mnemonic access for sending control
+        character to the child (such as Ctrl-C or Ctrl-D).  For example, to send
+        Ctrl-G (ASCII 7, bell, '\a')::
+            child.sendcontrol('g')
+        See also, sendintr() and sendeof().
+        '''
+        char = char.lower()
+        a = ord(char)
+        if 97 <= a <= 122:
+            a = a - ord('a') + 1
+            byte = bytes([a]).decode("ascii")
+            return self.pty.write(byte), byte
+        d = {'@': 0, '`': 0,
+            '[': 27, '{': 27,
+            '\\': 28, '|': 28,
+            ']': 29, '}': 29,
+            '^': 30, '~': 30,
+            '_': 31,
+            '?': 127}
+        if char not in d:
+            return 0, ''
+
+        byte = bytes([d[char]]).decode("ascii")
+        return self.pty.write(byte), byte
+
+    def sendeof(self):
+        """This sends an EOF to the child. This sends a character which causes
+        the pending parent output buffer to be sent to the waiting child
+        program without waiting for end-of-line. If it is the first character
+        of the line, the read() in the user program returns 0, which signifies
+        end-of-file. This means to work as expected a sendeof() has to be
+        called at the beginning of a line. This method does not send a newline.
+        It is the responsibility of the caller to ensure the eof is sent at the
+        beginning of a line."""
+        # Send control character 4 (Ctrl-D)
+        self.pty.write('\x04')
+
+    def sendintr(self):
+        """This sends a SIGINT to the child. It does not require
+        the SIGINT to be the first character on a line. """
+        # Send control character 3 (Ctrl-C)
+        self.pty.write('\x03')
+
+    def eof(self):
+        """This returns True if the EOF exception was ever raised.
+        """
+        return self.flag_eof
+
+    def getwinsize(self):
+        """Return the window size of the pseudoterminal as a tuple (rows, cols).
+        """
+        return self._winsize
+
+    def setwinsize(self, rows, cols):
+        """Set the terminal window size of the child tty.
+        """
+        self._winsize = (rows, cols)
+        self.pty.set_size(cols, rows)
+
+
+def _read_in_thread(address, pty: PTY, blocking: bool):
+    """Read data from the pty in a thread.
+    """
+    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    client.connect(address)
+
+    call = 0
+
+    while 1:
+        try:
+            data = pty.read(blocking=blocking) or '0011Ignore'
+            try:
+                client.send(bytes(data, 'utf-8'))
+            except socket.error:
+                break
+
+            # Handle end of file.
+            if pty.iseof():
+                try:
+                    client.send(b'')
+                except socket.error:
+                    pass
+                break
+
+            call += 1
+        except Exception as e:
+            break
+        time.sleep(1e-3)
+
+    client.close()

winpty/tests/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+"""winpty module tests."""

winpty/tests/test_pty.py

@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*-
+"""winpty wrapper tests."""
+
+# Standard library imports
+import os
+import time
+
+# Third party imports
+from winpty import PTY, WinptyError
+from winpty.enums import Backend
+from winpty.ptyprocess import which
+import pytest
+
+
+CMD = which('cmd').lower()
+
+
+def pty_factory(backend):
+    if os.environ.get('CI_RUNNING', None) == '1':
+        if backend == Backend.ConPTY:
+            os.environ['CONPTY_CI'] = '1'
+        elif backend == Backend.WinPTY:
+            os.environ.pop('CONPTY_CI', None)
+
+    @pytest.fixture(scope='function')
+    def pty_fixture():
+        pty = PTY(80, 20, backend=backend)
+        # loc = bytes(os.getcwd(), 'utf8')
+        assert pty.spawn(CMD)
+        time.sleep(0.3)
+        # if backend == Backend.ConPTY:
+        #     pty.write("\x1b[?1;0c\x1b[0;0R")
+        return pty
+    return pty_fixture
+
+
+conpty_provider = pty_factory(Backend.ConPTY)
+winpty_provider = pty_factory(Backend.WinPTY)
+
+
+@pytest.fixture(scope='module', params=['WinPTY', 'ConPTY'])
+def pty_fixture(request):
+    backend = request.param
+    if os.environ.get('CI_RUNNING', None) == '1':
+        if backend == 'ConPTY':
+            os.environ['CI'] = '1'
+            os.environ['CONPTY_CI'] = '1'
+        if backend == 'WinPTY':
+            os.environ.pop('CI', None)
+            os.environ.pop('CONPTY_CI', None)
+
+    backend = getattr(Backend, backend)
+    def _pty_factory():
+        try:
+            pty = PTY(80, 25, backend=backend)
+        except WinptyError:
+            pytest.skip()
+            return None
+        assert pty.spawn(CMD)
+        time.sleep(0.3)
+        return pty
+    return _pty_factory
+
+
+# @pytest.fixture(scope='function', params=[
+#     pytest.lazy_fixture('conpty_provider'),
+#     pytest.lazy_fixture('winpty_provider')])
+# def pty_fixture(request):
+#     pty = request.param
+#     return pty
+
+
+def test_read(pty_fixture, capsys):
+    pty = pty_fixture()
+    loc = os.getcwd()
+    readline = ''
+
+    with capsys.disabled():
+        start_time = time.time()
+        while loc not in readline:
+            if time.time() - start_time > 5:
+                break
+            readline += pty.read()
+    assert loc in readline or 'cmd' in readline
+    del pty
+
+
+def test_write(pty_fixture):
+    pty = pty_fixture()
+    line = pty.read()
+
+    str_text = 'Eggs, ham and spam ünicode'
+    # text = bytes(str_text, 'utf-8')
+    num_bytes = pty.write(str_text)
+
+    line = ''
+    start_time = time.time()
+    while str_text not in line:
+        if time.time() - start_time > 5:
+            break
+        line += pty.read()
+
+    assert str_text in line
+    del pty
+
+
+def test_isalive(pty_fixture):
+    pty = pty_fixture()
+    pty.write('exit\r\n')
+
+    text = 'exit'
+    line = ''
+    while text not in line:
+        try:
+            line += pty.read()
+        except Exception:
+            break
+
+    while pty.isalive():
+        try:
+            pty.read()
+            # continue
+        except Exception:
+            break
+
+    assert not pty.isalive()
+    del pty
+
+
+# def test_agent_spawn_fail(pty_fixture):
+#     pty = pty_fixture
+#     try:
+#         pty.spawn(CMD)
+#         assert False
+#     except WinptyError:
+#         pass
+
+
+# @pytest.mark.parametrize(
+#     'backend_name,backend',
+#     [("ConPTY", Backend.ConPTY), ('WinPTY', Backend.WinPTY)])
+# def test_pty_create_size_fail(backend_name, backend):
+#     try:
+#         PTY(80, -25, backend=backend)
+#         assert False
+#     except WinptyError:
+#         pass
+
+
+# def test_agent_resize_fail(pty_fixture):
+#     pty = pty_fixture()
+#     try:
+#         pty.set_size(-80, 70)
+#         assert False
+#     except WinptyError:
+#         pass
+#     finally:
+#         del pty
+
+
+def test_agent_resize(pty_fixture):
+    pty = pty_fixture()
+    pty.set_size(80, 70)
+    del pty

winpty/tests/test_ptyprocess.py

@@ -0,0 +1,268 @@
+# -*- coding: utf-8 -*-
+"""winpty wrapper tests."""
+
+# Standard library imports
+import asyncio
+import os
+import signal
+import time
+import sys
+import re
+
+# Third party imports
+import pytest
+from flaky import flaky
+
+# Local imports
+from winpty import WinptyError
+from winpty.enums import Backend
+from winpty.ptyprocess import PtyProcess, which
+
+
+
+@pytest.fixture(scope='module', params=['WinPTY', 'ConPTY'])
+def pty_fixture(request):
+    backend = request.param
+    if os.environ.get('CI_RUNNING', None) == '1':
+        if backend == 'ConPTY':
+            os.environ['CI'] = '1'
+            os.environ['CONPTY_CI'] = '1'
+        if backend == 'WinPTY':
+            os.environ.pop('CI', None)
+            os.environ.pop('CONPTY_CI', None)
+
+    backend = getattr(Backend, backend)
+    def _pty_factory(cmd=None, env=None):
+        cmd = cmd or 'cmd'
+        try:
+            pty = PtyProcess.spawn(cmd, env=env, backend=backend)
+        except WinptyError:
+            pytest.skip()
+            return None
+        return pty
+    # time.sleep(10)
+    _pty_factory.backend = request.param
+    return _pty_factory
+
+
+@flaky(max_runs=40, min_passes=1)
+def test_read(pty_fixture):
+    pty = pty_fixture()
+    loc = os.getcwd()
+    data = ''
+    tries = 0
+    while loc not in data and tries < 10:
+        try:
+            data += pty.read()
+        except EOFError:
+            pass
+        tries += 1
+    assert loc in data
+    pty.terminate()
+    time.sleep(2)
+
+
+@flaky(max_runs=40, min_passes=1)
+def test_write(pty_fixture):
+    pty = pty_fixture()
+
+    text = 'Eggs, ham and spam ünicode'
+    pty.write(text)
+
+    data = ''
+    tries = 0
+    while text not in data and tries < 10:
+        try:
+            data += pty.read()
+        except EOFError:
+            pass
+        tries += 1
+    assert text in data
+    pty.terminate()
+
+
+@pytest.mark.xfail(reason="It fails sometimes due to long strings")
+@flaky(max_runs=40, min_passes=1)
+def test_isalive(pty_fixture):
+    pty = pty_fixture()
+    time.sleep(4)
+
+    pty.write('echo \"foo\"\r\nexit\r\n')
+    data = ''
+    while True:
+        try:
+            print('Stuck')
+            data += pty.read()
+        except EOFError:
+            break
+
+    regex = re.compile(".*foo.*")
+    assert regex.findall(data)
+    assert not pty.isalive()
+    pty.terminate()
+
+
+@pytest.mark.xfail(reason="It fails sometimes due to long strings")
+@flaky(max_runs=40, min_passes=1)
+def test_readline(pty_fixture):
+    env = os.environ.copy()
+    env['foo'] = 'bar'
+    pty = pty_fixture(env=env)
+
+    # Ensure that the echo print has its own CRLF
+    pty.write('cls\r\n')
+    pty.write('echo %foo%\r\n')
+
+    data = ''
+    tries = 0
+    while 'bar' not in data and tries < 10:
+        data = pty.readline()
+        tries += 1
+
+    assert 'bar' in data
+
+    pty.terminate()
+
+
+def test_close(pty_fixture):
+    pty = pty_fixture()
+    pty.close()
+    assert not pty.isalive()
+
+
+def test_flush(pty_fixture):
+    pty = pty_fixture()
+    pty.flush()
+    pty.terminate()
+
+
+def test_intr(pty_fixture):
+    pty = pty_fixture(cmd=[sys.executable, 'import time; time.sleep(10)'])
+    pty.sendintr()
+    assert pty.wait() != 0
+
+
+def test_send_control(pty_fixture):
+    pty = pty_fixture(cmd=[sys.executable, 'import time; time.sleep(10)'])
+    pty.sendcontrol('d')
+    assert pty.wait() != 0
+
+
+@pytest.mark.skipif(which('cat') is None, reason="Requires cat on the PATH")
+def test_send_eof(pty_fixture):
+    cat = pty_fixture('cat')
+    cat.sendeof()
+    assert cat.wait() == 0
+
+
+def test_isatty(pty_fixture):
+    pty = pty_fixture()
+    assert pty.isatty()
+    pty.terminate()
+    assert not pty.isatty()
+
+
+def test_wait(pty_fixture):
+    pty = pty_fixture(cmd=[sys.executable, '--version'])
+    assert pty.wait() == 0
+
+
+def test_exit_status(pty_fixture):
+    pty = pty_fixture(cmd=[sys.executable])
+    pty.write('import sys;sys.exit(1)\r\n')
+    pty.wait()
+    assert pty.exitstatus == 1
+
+
+# @pytest.mark.timeout(30)
+def test_kill_sigterm(pty_fixture):
+    pty = pty_fixture()
+    pty.write('echo \"foo\"\r\nsleep 1000\r\n')
+    pty.read()
+    pty.kill(signal.SIGTERM)
+
+    while True:
+        try:
+            pty.read()
+        except EOFError:
+            break
+
+    assert not pty.isalive()
+    assert pty.exitstatus == signal.SIGTERM
+
+
+# @pytest.mark.timeout(30)
+def test_terminate(pty_fixture):
+    pty = pty_fixture()
+    pty.write('echo \"foo\"\r\nsleep 1000\r\n')
+    pty.read()
+    pty.terminate()
+
+    while True:
+        try:
+            pty.read()
+        except EOFError:
+            break
+
+    assert not pty.isalive()
+    assert pty.closed
+
+
+# @pytest.mark.timeout(30)
+def test_terminate_force(pty_fixture):
+    pty = pty_fixture()
+    pty.write('echo \"foo\"\r\nsleep 1000\r\n')
+    pty.read()
+    pty.terminate(force=True)
+
+    while True:
+        try:
+            pty.read()
+        except EOFError:
+            break
+
+    assert not pty.isalive()
+    assert pty.closed
+
+
+def test_terminate_loop(pty_fixture):
+    pty = pty_fixture()
+    loop = asyncio.SelectorEventLoop()
+    asyncio.set_event_loop(loop)
+
+    def reader():
+        try:
+            data = pty.read()
+        except EOFError:
+            loop.remove_reader(pty.fd)
+            loop.stop()
+
+    loop.add_reader(pty.fd, reader)
+    loop.call_soon(pty.write, 'echo \"foo\"\r\nsleep 1000\r\n')
+    loop.call_soon(pty.terminate, True)
+
+    try:
+        loop.run_forever()
+    finally:
+        loop.close()
+
+    assert not pty.isalive()
+    assert pty.closed
+
+
+def test_getwinsize(pty_fixture):
+    pty = pty_fixture()
+    assert pty.getwinsize() == (24, 80)
+    pty.terminate()
+
+
+def test_setwinsize(pty_fixture):
+    pty = pty_fixture()
+    pty.setwinsize(50, 110)
+    assert pty.getwinsize() == (50, 110)
+    pty.terminate()
+
+    pty = PtyProcess.spawn('cmd', dimensions=(60, 120))
+    assert pty.getwinsize() == (60, 120)
+    pty.terminate()
+

winpty/winpty.pyi

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+
+"""Stub typing declarations for the native PTY object."""
+
+# Standard library imports
+from typing import Optional
+
+# Local imports
+from .enums import MouseMode, AgentConfig
+
+__version__: str
+
+class WinptyError(Exception): ...
+
+class PTY:
+    def __init__(
+        self,
+        cols: int,
+        rows: int,
+        backend: Optional[int] = None,
+        mouse_mode: int = MouseMode.WINPTY_MOUSE_MODE_NONE,
+        timeout: int = 30000,
+        agent_config: int = AgentConfig.WINPTY_FLAG_COLOR_ESCAPES,
+    ): ...
+    def spawn(
+        self,
+        appname: str,
+        cmdline: Optional[str] = None,
+        cwd: Optional[str] = None,
+        env: Optional[str] = None,
+    ) -> bool: ...
+    def set_size(self, cols: int, rows: int): ...
+    def read(self, blocking: bool = False) -> str: ...
+    def write(self, to_write: str) -> int: ...
+    def isalive(self) -> bool: ...
+    def get_exitstatus(self) -> Optional[int]: ...
+    def iseof(self) -> bool: ...
+    def cancel_io(self) -> bool: ...
+    @property
+    def pid(self) -> Optional[int]: ...
+    @property
+    def fd(self) -> Optional[int]: ...