Remove windows python distribution from repo and add requirements.txt

1 files changed, 0 insertions, 320 deletions

diff --git a/python/gevent/_fileobjectposix.py b/python/gevent/_fileobjectposix.py
deleted file mode 100644
index 93dd65f..0000000
--- a/python/gevent/_fileobjectposix.py
+++ /dev/null
@@ -1,320 +0,0 @@
-from __future__ import absolute_import
-import os
-import io
-from io import BufferedReader
-from io import BufferedWriter
-from io import BytesIO
-from io import DEFAULT_BUFFER_SIZE
-from io import RawIOBase
-from io import UnsupportedOperation
-
-from gevent._fileobjectcommon import cancel_wait_ex
-from gevent._fileobjectcommon import FileObjectBase
-from gevent.hub import get_hub
-from gevent.os import _read
-from gevent.os import _write
-from gevent.os import ignored_errors
-from gevent.os import make_nonblocking
-
-
-class GreenFileDescriptorIO(RawIOBase):
-
-    # Note that RawIOBase has a __del__ method that calls
-    # self.close(). (In C implementations like CPython, this is
-    # the type's tp_dealloc slot; prior to Python 3, the object doesn't
-    # appear to have a __del__ method, even though it functionally does)
-
-    _read_event = None
-    _write_event = None
-    _closed = False
-    _seekable = None
-
-    def __init__(self, fileno, mode='r', closefd=True):
-        RawIOBase.__init__(self) # Python 2: pylint:disable=no-member,non-parent-init-called
-        self._closefd = closefd
-        self._fileno = fileno
-        make_nonblocking(fileno)
-        readable = 'r' in mode
-        writable = 'w' in mode
-        self.hub = get_hub()
-
-        io_watcher = self.hub.loop.io
-        if readable:
-            self._read_event = io_watcher(fileno, 1)
-
-        if writable:
-            self._write_event = io_watcher(fileno, 2)
-
-    def readable(self):
-        return self._read_event is not None
-
-    def writable(self):
-        return self._write_event is not None
-
-    def seekable(self):
-        if self._seekable is None:
-            try:
-                os.lseek(self._fileno, 0, os.SEEK_CUR)
-            except OSError:
-                self._seekable = False
-            else:
-                self._seekable = True
-        return self._seekable
-
-    def fileno(self):
-        return self._fileno
-
-    @property
-    def closed(self):
-        return self._closed
-
-    def close(self):
-        if self._closed:
-            return
-        self.flush()
-        # TODO: Can we use 'read_event is not None and write_event is
-        # not None' to mean _closed?
-        self._closed = True
-        read_event = self._read_event
-        write_event = self._write_event
-        self._read_event = self._write_event = None
-
-        if read_event is not None:
-            self.hub.cancel_wait(read_event, cancel_wait_ex, True)
-        if write_event is not None:
-            self.hub.cancel_wait(write_event, cancel_wait_ex, True)
-
-        fileno = self._fileno
-        if self._closefd:
-            self._fileno = None
-            os.close(fileno)
-
-    # RawIOBase provides a 'read' method that will call readall() if
-    # the `size` was missing or -1 and otherwise call readinto(). We
-    # want to take advantage of this to avoid single byte reads when
-    # possible. This is highlighted by a bug in BufferedIOReader that
-    # calls read() in a loop when its readall() method is invoked;
-    # this was fixed in Python 3.3, but we still need our workaround for 2.7. See
-    # https://github.com/gevent/gevent/issues/675)
-    def __read(self, n):
-        if self._read_event is None:
-            raise UnsupportedOperation('read')
-        while True:
-            try:
-                return _read(self._fileno, n)
-            except (IOError, OSError) as ex:
-                if ex.args[0] not in ignored_errors:
-                    raise
-            self.hub.wait(self._read_event)
-
-    def readall(self):
-        ret = BytesIO()
-        while True:
-            data = self.__read(DEFAULT_BUFFER_SIZE)
-            if not data:
-                break
-            ret.write(data)
-        return ret.getvalue()
-
-    def readinto(self, b):
-        data = self.__read(len(b))
-        n = len(data)
-        try:
-            b[:n] = data
-        except TypeError as err:
-            import array
-            if not isinstance(b, array.array):
-                raise err
-            b[:n] = array.array(b'b', data)
-        return n
-
-    def write(self, b):
-        if self._write_event is None:
-            raise UnsupportedOperation('write')
-        while True:
-            try:
-                return _write(self._fileno, b)
-            except (IOError, OSError) as ex:
-                if ex.args[0] not in ignored_errors:
-                    raise
-            self.hub.wait(self._write_event)
-
-    def seek(self, offset, whence=0):
-        return os.lseek(self._fileno, offset, whence)
-
-class FlushingBufferedWriter(BufferedWriter):
-
-    def write(self, b):
-        ret = BufferedWriter.write(self, b)
-        self.flush()
-        return ret
-
-class FileObjectPosix(FileObjectBase):
-    """
-    A file-like object that operates on non-blocking files but
-    provides a synchronous, cooperative interface.
-
-    .. caution::
-         This object is only effective wrapping files that can be used meaningfully
-         with :func:`select.select` such as sockets and pipes.
-
-         In general, on most platforms, operations on regular files
-         (e.g., ``open('a_file.txt')``) are considered non-blocking
-         already, even though they can take some time to complete as
-         data is copied to the kernel and flushed to disk: this time
-         is relatively bounded compared to sockets or pipes, though.
-         A :func:`~os.read` or :func:`~os.write` call on such a file
-         will still effectively block for some small period of time.
-         Therefore, wrapping this class around a regular file is
-         unlikely to make IO gevent-friendly: reading or writing large
-         amounts of data could still block the event loop.
-
-         If you'll be working with regular files and doing IO in large
-         chunks, you may consider using
-         :class:`~gevent.fileobject.FileObjectThread` or
-         :func:`~gevent.os.tp_read` and :func:`~gevent.os.tp_write` to bypass this
-         concern.
-
-    .. note::
-         Random read/write (e.g., ``mode='rwb'``) is not supported.
-         For that, use :class:`io.BufferedRWPair` around two instance of this
-         class.
-
-    .. tip::
-         Although this object provides a :meth:`fileno` method and so
-         can itself be passed to :func:`fcntl.fcntl`, setting the
-         :data:`os.O_NONBLOCK` flag will have no effect (reads will
-         still block the greenlet, although other greenlets can run).
-         However, removing that flag *will cause this object to no
-         longer be cooperative* (other greenlets will no longer run).
-
-         You can use the internal ``fileio`` attribute of this object
-         (a :class:`io.RawIOBase`) to perform non-blocking byte reads.
-         Note, however, that once you begin directly using this
-         attribute, the results from using methods of *this* object
-         are undefined, especially in text mode. (See :issue:`222`.)
-
-    .. versionchanged:: 1.1
-       Now uses the :mod:`io` package internally. Under Python 2, previously
-       used the undocumented class :class:`socket._fileobject`. This provides
-       better file-like semantics (and portability to Python 3).
-    .. versionchanged:: 1.2a1
-       Document the ``fileio`` attribute for non-blocking reads.
-    """
-
-    #: platform specific default for the *bufsize* parameter
-    default_bufsize = io.DEFAULT_BUFFER_SIZE
-
-    def __init__(self, fobj, mode='rb', bufsize=-1, close=True):
-        """
-        :param fobj: Either an integer fileno, or an object supporting the
-            usual :meth:`socket.fileno` method. The file *will* be
-            put in non-blocking mode using :func:`gevent.os.make_nonblocking`.
-        :keyword str mode: The manner of access to the file, one of "rb", "rU" or "wb"
-            (where the "b" or "U" can be omitted).
-            If "U" is part of the mode, universal newlines will be used. On Python 2,
-            if 't' is not in the mode, this will result in returning byte (native) strings;
-            putting 't'  in the mode will return text strings. This may cause
-            :exc:`UnicodeDecodeError` to be raised.
-        :keyword int bufsize: If given, the size of the buffer to use. The default
-            value means to use a platform-specific default
-            Other values are interpreted as for the :mod:`io` package.
-            Buffering is ignored in text mode.
-
-        .. versionchanged:: 1.3a1
-
-           On Python 2, enabling universal newlines no longer forces unicode
-           IO.
-
-        .. versionchanged:: 1.2a1
-
-           A bufsize of 0 in write mode is no longer forced to be 1.
-           Instead, the underlying buffer is flushed after every write
-           operation to simulate a bufsize of 0. In gevent 1.0, a
-           bufsize of 0 was flushed when a newline was written, while
-           in gevent 1.1 it was flushed when more than one byte was
-           written. Note that this may have performance impacts.
-        """
-
-        if isinstance(fobj, int):
-            fileno = fobj
-            fobj = None
-        else:
-            fileno = fobj.fileno()
-        if not isinstance(fileno, int):
-            raise TypeError('fileno must be int: %r' % fileno)
-
-        orig_mode = mode
-        mode = (mode or 'rb').replace('b', '')
-        if 'U' in mode:
-            self._translate = True
-            if bytes is str and 't' not in mode:
-                # We're going to be producing unicode objects, but
-                # universal newlines doesn't do that in the stdlib,
-                # so fix that to return str objects. The fix is two parts:
-                # first, set an encoding on the stream that can round-trip
-                # all bytes, and second, decode all bytes once they've been read.
-                self._translate_encoding = 'latin-1'
-                import functools
-
-                def wrap_method(m):
-                    if m.__name__.startswith("read"):
-                        @functools.wraps(m)
-                        def wrapped(*args, **kwargs):
-                            result = m(*args, **kwargs)
-                            assert isinstance(result, unicode) # pylint:disable=undefined-variable
-                            return result.encode('latin-1')
-                        return wrapped
-                    return m
-                self._wrap_method = wrap_method
-            mode = mode.replace('U', '')
-        else:
-            self._translate = False
-
-        mode = mode.replace('t', '')
-
-        if len(mode) != 1 and mode not in 'rw': # pragma: no cover
-            # Python 3 builtin `open` raises a ValueError for invalid modes;
-            # Python 2 ignores it. In the past, we raised an AssertionError, if __debug__ was
-            # enabled (which it usually was). Match Python 3 because it makes more sense
-            # and because __debug__ may not be enabled.
-            # NOTE: This is preventing a mode like 'rwb' for binary random access;
-            # that code was never tested and was explicitly marked as "not used"
-            raise ValueError('mode can only be [rb, rU, wb], not %r' % (orig_mode,))
-
-        self._fobj = fobj
-
-        # This attribute is documented as available for non-blocking reads.
-        self.fileio = GreenFileDescriptorIO(fileno, mode, closefd=close)
-
-        self._orig_bufsize = bufsize
-        if bufsize < 0 or bufsize == 1:
-            bufsize = self.default_bufsize
-        elif bufsize == 0:
-            bufsize = 1
-
-        if mode == 'r':
-            IOFamily = BufferedReader
-        else:
-            assert mode == 'w'
-            IOFamily = BufferedWriter
-            if self._orig_bufsize == 0:
-                # We could also simply pass self.fileio as *io*, but this way
-                # we at least consistently expose a BufferedWriter in our *io*
-                # attribute.
-                IOFamily = FlushingBufferedWriter
-
-        super(FileObjectPosix, self).__init__(IOFamily(self.fileio, bufsize), close)
-
-    def _do_close(self, fobj, closefd):
-        try:
-            fobj.close()
-            # self.fileio already knows whether or not to close the
-            # file descriptor
-            self.fileio.close()
-        finally:
-            self._fobj = None
-            self.fileio = None
-
-    def __iter__(self):
-        return self._io