springsuite: planemo/lib/python3.7/site-packages/click/

comparison planemo/lib/python3.7/site-packages/click/_compat.py @ 0:d30785e31577 draft

"planemo upload commit 6eee67778febed82ddd413c3ca40b3183a3898f1"

author	guerler
date	Fri, 31 Jul 2020 00:18:57 -0400
parents
children

comparison

equal deleted inserted replaced

--1:000000000000
+:d30785e31577
+# flake8: noqa
+import codecs
+import io
+import os
+import re
+import sys
+from weakref import WeakKeyDictionary
+PY2 = sys.version_info[0] == 2
+CYGWIN = sys.platform.startswith("cygwin")
+MSYS2 = sys.platform.startswith("win") and ("GCC" in sys.version)
+# Determine local App Engine environment, per Google's own suggestion
+APP_ENGINE = "APPENGINE_RUNTIME" in os.environ and "Development/" in os.environ.get(
+"SERVER_SOFTWARE", ""
+)
+WIN = sys.platform.startswith("win") and not APP_ENGINE and not MSYS2
+DEFAULT_COLUMNS = 80
+_ansi_re = re.compile(r"\033\[[;?0-9]*[a-zA-Z]")
+def get_filesystem_encoding():
+return sys.getfilesystemencoding() or sys.getdefaultencoding()
+def _make_text_stream(
+stream, encoding, errors, force_readable=False, force_writable=False
+):
+if encoding is None:
+encoding = get_best_encoding(stream)
+if errors is None:
+errors = "replace"
+return _NonClosingTextIOWrapper(
+stream,
+encoding,
+errors,
+line_buffering=True,
+force_readable=force_readable,
+force_writable=force_writable,
+)
+def is_ascii_encoding(encoding):
+"""Checks if a given encoding is ascii."""
+try:
+return codecs.lookup(encoding).name == "ascii"
+except LookupError:
+return False
+def get_best_encoding(stream):
+"""Returns the default stream encoding if not found."""
+rv = getattr(stream, "encoding", None) or sys.getdefaultencoding()
+if is_ascii_encoding(rv):
+return "utf-8"
+return rv
+class _NonClosingTextIOWrapper(io.TextIOWrapper):
+def __init__(
+self,
+stream,
+encoding,
+errors,
+force_readable=False,
+force_writable=False,
+**extra
+):
+self._stream = stream = _FixupStream(stream, force_readable, force_writable)
+io.TextIOWrapper.__init__(self, stream, encoding, errors, **extra)
+# The io module is a place where the Python 3 text behavior
+# was forced upon Python 2, so we need to unbreak
+# it to look like Python 2.
+if PY2:
+def write(self, x):
+if isinstance(x, str) or is_bytes(x):
+try:
+self.flush()
+except Exception:
+pass
+return self.buffer.write(str(x))
+return io.TextIOWrapper.write(self, x)
+def writelines(self, lines):
+for line in lines:
+self.write(line)
+def __del__(self):
+try:
+self.detach()
+except Exception:
+pass
+def isatty(self):
+# https://bitbucket.org/pypy/pypy/issue/1803
+return self._stream.isatty()
+class _FixupStream(object):
+"""The new io interface needs more from streams than streams
+traditionally implement.  As such, this fix-up code is necessary in
+some circumstances.
+The forcing of readable and writable flags are there because some tools
+put badly patched objects on sys (one such offender are certain version
+of jupyter notebook).
+"""
+def __init__(self, stream, force_readable=False, force_writable=False):
+self._stream = stream
+self._force_readable = force_readable
+self._force_writable = force_writable
+def __getattr__(self, name):
+return getattr(self._stream, name)
+def read1(self, size):
+f = getattr(self._stream, "read1", None)
+if f is not None:
+return f(size)
+# We only dispatch to readline instead of read in Python 2 as we
+# do not want cause problems with the different implementation
+# of line buffering.
+if PY2:
+return self._stream.readline(size)
+return self._stream.read(size)
+def readable(self):
+if self._force_readable:
+return True
+x = getattr(self._stream, "readable", None)
+if x is not None:
+return x()
+try:
+self._stream.read(0)
+except Exception:
+return False
+return True
+def writable(self):
+if self._force_writable:
+return True
+x = getattr(self._stream, "writable", None)
+if x is not None:
+return x()
+try:
+self._stream.write("")
+except Exception:
+try:
+self._stream.write(b"")
+except Exception:
+return False
+return True
+def seekable(self):
+x = getattr(self._stream, "seekable", None)
+if x is not None:
+return x()
+try:
+self._stream.seek(self._stream.tell())
+except Exception:
+return False
+return True
+if PY2:
+text_type = unicode
+raw_input = raw_input
+string_types = (str, unicode)
+int_types = (int, long)
+iteritems = lambda x: x.iteritems()
+range_type = xrange
+def is_bytes(x):
+return isinstance(x, (buffer, bytearray))
+_identifier_re = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*$")
+# For Windows, we need to force stdout/stdin/stderr to binary if it's
+# fetched for that.  This obviously is not the most correct way to do
+# it as it changes global state.  Unfortunately, there does not seem to
+# be a clear better way to do it as just reopening the file in binary
+# mode does not change anything.
+#
+# An option would be to do what Python 3 does and to open the file as
+# binary only, patch it back to the system, and then use a wrapper
+# stream that converts newlines.  It's not quite clear what's the
+# correct option here.
+#
+# This code also lives in _winconsole for the fallback to the console
+# emulation stream.
+#
+# There are also Windows environments where the `msvcrt` module is not
+# available (which is why we use try-catch instead of the WIN variable
+# here), such as the Google App Engine development server on Windows. In
+# those cases there is just nothing we can do.
+def set_binary_mode(f):
+return f
+try:
+import msvcrt
+except ImportError:
+pass
+else:
+def set_binary_mode(f):
+try:
+fileno = f.fileno()
+except Exception:
+pass
+else:
+msvcrt.setmode(fileno, os.O_BINARY)
+return f
+try:
+import fcntl
+except ImportError:
+pass
+else:
+def set_binary_mode(f):
+try:
+fileno = f.fileno()
+except Exception:
+pass
+else:
+flags = fcntl.fcntl(fileno, fcntl.F_GETFL)
+fcntl.fcntl(fileno, fcntl.F_SETFL, flags & ~os.O_NONBLOCK)
+return f
+def isidentifier(x):
+return _identifier_re.search(x) is not None
+def get_binary_stdin():
+return set_binary_mode(sys.stdin)
+def get_binary_stdout():
+_wrap_std_stream("stdout")
+return set_binary_mode(sys.stdout)
+def get_binary_stderr():
+_wrap_std_stream("stderr")
+return set_binary_mode(sys.stderr)
+def get_text_stdin(encoding=None, errors=None):
+rv = _get_windows_console_stream(sys.stdin, encoding, errors)
+if rv is not None:
+return rv
+return _make_text_stream(sys.stdin, encoding, errors, force_readable=True)
+def get_text_stdout(encoding=None, errors=None):
+_wrap_std_stream("stdout")
+rv = _get_windows_console_stream(sys.stdout, encoding, errors)
+if rv is not None:
+return rv
+return _make_text_stream(sys.stdout, encoding, errors, force_writable=True)
+def get_text_stderr(encoding=None, errors=None):
+_wrap_std_stream("stderr")
+rv = _get_windows_console_stream(sys.stderr, encoding, errors)
+if rv is not None:
+return rv
+return _make_text_stream(sys.stderr, encoding, errors, force_writable=True)
+def filename_to_ui(value):
+if isinstance(value, bytes):
+value = value.decode(get_filesystem_encoding(), "replace")
+return value
+else:
+import io
+text_type = str
+raw_input = input
+string_types = (str,)
+int_types = (int,)
+range_type = range
+isidentifier = lambda x: x.isidentifier()
+iteritems = lambda x: iter(x.items())
+def is_bytes(x):
+return isinstance(x, (bytes, memoryview, bytearray))
+def _is_binary_reader(stream, default=False):
+try:
+return isinstance(stream.read(0), bytes)
+except Exception:
+return default
+# This happens in some cases where the stream was already
+# closed.  In this case, we assume the default.
+def _is_binary_writer(stream, default=False):
+try:
+stream.write(b"")
+except Exception:
+try:
+stream.write("")
+return False
+except Exception:
+pass
+return default
+return True
+def _find_binary_reader(stream):
+# We need to figure out if the given stream is already binary.
+# This can happen because the official docs recommend detaching
+# the streams to get binary streams.  Some code might do this, so
+# we need to deal with this case explicitly.
+if _is_binary_reader(stream, False):
+return stream
+buf = getattr(stream, "buffer", None)
+# Same situation here; this time we assume that the buffer is
+# actually binary in case it's closed.
+if buf is not None and _is_binary_reader(buf, True):
+return buf
+def _find_binary_writer(stream):
+# We need to figure out if the given stream is already binary.
+# This can happen because the official docs recommend detatching
+# the streams to get binary streams.  Some code might do this, so
+# we need to deal with this case explicitly.
+if _is_binary_writer(stream, False):
+return stream
+buf = getattr(stream, "buffer", None)
+# Same situation here; this time we assume that the buffer is
+# actually binary in case it's closed.
+if buf is not None and _is_binary_writer(buf, True):
+return buf
+def _stream_is_misconfigured(stream):
+"""A stream is misconfigured if its encoding is ASCII."""
+# If the stream does not have an encoding set, we assume it's set
+# to ASCII.  This appears to happen in certain unittest
+# environments.  It's not quite clear what the correct behavior is
+# but this at least will force Click to recover somehow.
+return is_ascii_encoding(getattr(stream, "encoding", None) or "ascii")
+def _is_compat_stream_attr(stream, attr, value):
+"""A stream attribute is compatible if it is equal to the
+desired value or the desired value is unset and the attribute
+has a value.
+"""
+stream_value = getattr(stream, attr, None)
+return stream_value == value or (value is None and stream_value is not None)
+def _is_compatible_text_stream(stream, encoding, errors):
+"""Check if a stream's encoding and errors attributes are
+compatible with the desired values.
+"""
+return _is_compat_stream_attr(
+stream, "encoding", encoding
+) and _is_compat_stream_attr(stream, "errors", errors)
+def _force_correct_text_stream(
+text_stream,
+encoding,
+errors,
+is_binary,
+find_binary,
+force_readable=False,
+force_writable=False,
+):
+if is_binary(text_stream, False):
+binary_reader = text_stream
+else:
+# If the stream looks compatible, and won't default to a
+# misconfigured ascii encoding, return it as-is.
+if _is_compatible_text_stream(text_stream, encoding, errors) and not (
+encoding is None and _stream_is_misconfigured(text_stream)
+):
+return text_stream
+# Otherwise, get the underlying binary reader.
+binary_reader = find_binary(text_stream)
+# If that's not possible, silently use the original reader
+# and get mojibake instead of exceptions.
+if binary_reader is None:
+return text_stream
+# Default errors to replace instead of strict in order to get
+# something that works.
+if errors is None:
+errors = "replace"
+# Wrap the binary stream in a text stream with the correct
+# encoding parameters.
+return _make_text_stream(
+binary_reader,
+encoding,
+errors,
+force_readable=force_readable,
+force_writable=force_writable,
+)
+def _force_correct_text_reader(text_reader, encoding, errors, force_readable=False):
+return _force_correct_text_stream(
+text_reader,
+encoding,
+errors,
+_is_binary_reader,
+_find_binary_reader,
+force_readable=force_readable,
+)
+def _force_correct_text_writer(text_writer, encoding, errors, force_writable=False):
+return _force_correct_text_stream(
+text_writer,
+encoding,
+errors,
+_is_binary_writer,
+_find_binary_writer,
+force_writable=force_writable,
+)
+def get_binary_stdin():
+reader = _find_binary_reader(sys.stdin)
+if reader is None:
+raise RuntimeError("Was not able to determine binary stream for sys.stdin.")
+return reader
+def get_binary_stdout():
+writer = _find_binary_writer(sys.stdout)
+if writer is None:
+raise RuntimeError(
+"Was not able to determine binary stream for sys.stdout."
+)
+return writer
+def get_binary_stderr():
+writer = _find_binary_writer(sys.stderr)
+if writer is None:
+raise RuntimeError(
+"Was not able to determine binary stream for sys.stderr."
+)
+return writer
+def get_text_stdin(encoding=None, errors=None):
+rv = _get_windows_console_stream(sys.stdin, encoding, errors)
+if rv is not None:
+return rv
+return _force_correct_text_reader(
+sys.stdin, encoding, errors, force_readable=True
+)
+def get_text_stdout(encoding=None, errors=None):
+rv = _get_windows_console_stream(sys.stdout, encoding, errors)
+if rv is not None:
+return rv
+return _force_correct_text_writer(
+sys.stdout, encoding, errors, force_writable=True
+)
+def get_text_stderr(encoding=None, errors=None):
+rv = _get_windows_console_stream(sys.stderr, encoding, errors)
+if rv is not None:
+return rv
+return _force_correct_text_writer(
+sys.stderr, encoding, errors, force_writable=True
+)
+def filename_to_ui(value):
+if isinstance(value, bytes):
+value = value.decode(get_filesystem_encoding(), "replace")
+else:
+value = value.encode("utf-8", "surrogateescape").decode("utf-8", "replace")
+return value
+def get_streerror(e, default=None):
+if hasattr(e, "strerror"):
+msg = e.strerror
+else:
+if default is not None:
+msg = default
+else:
+msg = str(e)
+if isinstance(msg, bytes):
+msg = msg.decode("utf-8", "replace")
+return msg
+def _wrap_io_open(file, mode, encoding, errors):
+"""On Python 2, :func:`io.open` returns a text file wrapper that
+requires passing ``unicode`` to ``write``. Need to open the file in
+binary mode then wrap it in a subclass that can write ``str`` and
+``unicode``.
+Also handles not passing ``encoding`` and ``errors`` in binary mode.
+"""
+binary = "b" in mode
+if binary:
+kwargs = {}
+else:
+kwargs = {"encoding": encoding, "errors": errors}
+if not PY2 or binary:
+return io.open(file, mode, **kwargs)
+f = io.open(file, "{}b".format(mode.replace("t", "")))
+return _make_text_stream(f, **kwargs)
+def open_stream(filename, mode="r", encoding=None, errors="strict", atomic=False):
+binary = "b" in mode
+# Standard streams first.  These are simple because they don't need
+# special handling for the atomic flag.  It's entirely ignored.
+if filename == "-":
+if any(m in mode for m in ["w", "a", "x"]):
+if binary:
+return get_binary_stdout(), False
+return get_text_stdout(encoding=encoding, errors=errors), False
+if binary:
+return get_binary_stdin(), False
+return get_text_stdin(encoding=encoding, errors=errors), False
+# Non-atomic writes directly go out through the regular open functions.
+if not atomic:
+return _wrap_io_open(filename, mode, encoding, errors), True
+# Some usability stuff for atomic writes
+if "a" in mode:
+raise ValueError(
+"Appending to an existing file is not supported, because that"
+" would involve an expensive `copy`-operation to a temporary"
+" file. Open the file in normal `w`-mode and copy explicitly"
+" if that's what you're after."
+)
+if "x" in mode:
+raise ValueError("Use the `overwrite`-parameter instead.")
+if "w" not in mode:
+raise ValueError("Atomic writes only make sense with `w`-mode.")
+# Atomic writes are more complicated.  They work by opening a file
+# as a proxy in the same folder and then using the fdopen
+# functionality to wrap it in a Python file.  Then we wrap it in an
+# atomic file that moves the file over on close.
+import errno
+import random
+try:
+perm = os.stat(filename).st_mode
+except OSError:
+perm = None
+flags = os.O_RDWR | os.O_CREAT | os.O_EXCL
+if binary:
+flags |= getattr(os, "O_BINARY", 0)
+while True:
+tmp_filename = os.path.join(
+os.path.dirname(filename),
+".__atomic-write{:08x}".format(random.randrange(1 << 32)),
+)
+try:
+fd = os.open(tmp_filename, flags, 0o666 if perm is None else perm)
+break
+except OSError as e:
+if e.errno == errno.EEXIST or (
+os.name == "nt"
+and e.errno == errno.EACCES
+and os.path.isdir(e.filename)
+and os.access(e.filename, os.W_OK)
+):
+continue
+raise
+if perm is not None:
+os.chmod(tmp_filename, perm)  # in case perm includes bits in umask
+f = _wrap_io_open(fd, mode, encoding, errors)
+return _AtomicFile(f, tmp_filename, os.path.realpath(filename)), True
+# Used in a destructor call, needs extra protection from interpreter cleanup.
+if hasattr(os, "replace"):
+_replace = os.replace
+_can_replace = True
+else:
+_replace = os.rename
+_can_replace = not WIN
+class _AtomicFile(object):
+def __init__(self, f, tmp_filename, real_filename):
+self._f = f
+self._tmp_filename = tmp_filename
+self._real_filename = real_filename
+self.closed = False
+@property
+def name(self):
+return self._real_filename
+def close(self, delete=False):
+if self.closed:
+return
+self._f.close()
+if not _can_replace:
+try:
+os.remove(self._real_filename)
+except OSError:
+pass
+_replace(self._tmp_filename, self._real_filename)
+self.closed = True
+def __getattr__(self, name):
+return getattr(self._f, name)
+def __enter__(self):
+return self
+def __exit__(self, exc_type, exc_value, tb):
+self.close(delete=exc_type is not None)
+def __repr__(self):
+return repr(self._f)
+auto_wrap_for_ansi = None
+colorama = None
+get_winterm_size = None
+def strip_ansi(value):
+return _ansi_re.sub("", value)
+def _is_jupyter_kernel_output(stream):
+if WIN:
+# TODO: Couldn't test on Windows, should't try to support until
+# someone tests the details wrt colorama.
+return
+while isinstance(stream, (_FixupStream, _NonClosingTextIOWrapper)):
+stream = stream._stream
+return stream.__class__.__module__.startswith("ipykernel.")
+def should_strip_ansi(stream=None, color=None):
+if color is None:
+if stream is None:
+stream = sys.stdin
+return not isatty(stream) and not _is_jupyter_kernel_output(stream)
+return not color
+# If we're on Windows, we provide transparent integration through
+# colorama.  This will make ANSI colors through the echo function
+# work automatically.
+if WIN:
+# Windows has a smaller terminal
+DEFAULT_COLUMNS = 79
+from ._winconsole import _get_windows_console_stream, _wrap_std_stream
+def _get_argv_encoding():
+import locale
+return locale.getpreferredencoding()
+if PY2:
+def raw_input(prompt=""):
+sys.stderr.flush()
+if prompt:
+stdout = _default_text_stdout()
+stdout.write(prompt)
+stdin = _default_text_stdin()
+return stdin.readline().rstrip("\r\n")
+try:
+import colorama
+except ImportError:
+pass
+else:
+_ansi_stream_wrappers = WeakKeyDictionary()
+def auto_wrap_for_ansi(stream, color=None):
+"""This function wraps a stream so that calls through colorama
+are issued to the win32 console API to recolor on demand.  It
+also ensures to reset the colors if a write call is interrupted
+to not destroy the console afterwards.
+"""
+try:
+cached = _ansi_stream_wrappers.get(stream)
+except Exception:
+cached = None
+if cached is not None:
+return cached
+strip = should_strip_ansi(stream, color)
+ansi_wrapper = colorama.AnsiToWin32(stream, strip=strip)
+rv = ansi_wrapper.stream
+_write = rv.write
+def _safe_write(s):
+try:
+return _write(s)
+except:
+ansi_wrapper.reset_all()
+raise
+rv.write = _safe_write
+try:
+_ansi_stream_wrappers[stream] = rv
+except Exception:
+pass
+return rv
+def get_winterm_size():
+win = colorama.win32.GetConsoleScreenBufferInfo(
+colorama.win32.STDOUT
+).srWindow
+return win.Right - win.Left, win.Bottom - win.Top
+else:
+def _get_argv_encoding():
+return getattr(sys.stdin, "encoding", None) or get_filesystem_encoding()
+_get_windows_console_stream = lambda *x: None
+_wrap_std_stream = lambda *x: None
+def term_len(x):
+return len(strip_ansi(x))
+def isatty(stream):
+try:
+return stream.isatty()
+except Exception:
+return False
+def _make_cached_stream_func(src_func, wrapper_func):
+cache = WeakKeyDictionary()
+def func():
+stream = src_func()
+try:
+rv = cache.get(stream)
+except Exception:
+rv = None
+if rv is not None:
+return rv
+rv = wrapper_func()
+try:
+stream = src_func()  # In case wrapper_func() modified the stream
+cache[stream] = rv
+except Exception:
+pass
+return rv
+return func
+_default_text_stdin = _make_cached_stream_func(lambda: sys.stdin, get_text_stdin)
+_default_text_stdout = _make_cached_stream_func(lambda: sys.stdout, get_text_stdout)
+_default_text_stderr = _make_cached_stream_func(lambda: sys.stderr, get_text_stderr)
+binary_streams = {
+"stdin": get_binary_stdin,
+"stdout": get_binary_stdout,
+"stderr": get_binary_stderr,
+}
+text_streams = {
+"stdin": get_text_stdin,
+"stdout": get_text_stdout,
+"stderr": get_text_stderr,
+}

Mercurial > repos > guerler > springsuite

comparison planemo/lib/python3.7/site-packages/click/_compat.py @ 0:d30785e31577 draft