colorama-0.3.7/0000755000076600000240000000000012667514340013760 5ustar arnonystaff00000000000000colorama-0.3.7/CHANGELOG.rst0000644000076600000240000001522712667513755016021 0ustar arnonystaff000000000000000.3.7 * Fix issue #84: check if stream has 'closed' attribute before testing it * Fix issue #74: objects might become None at exit 0.3.6 * Fix issue #81: fix ValueError when a closed stream was used 0.3.5 * Bumping version to re-upload a wheel distribution 0.3.4 * Fix issue #47 and #80 - stream redirection now strips ANSI codes on Linux * Fix issue #53 - strip readline markers * Fix issue #32 - assign orig_stdout and orig_stderr when initialising * Fix issue #57 - Fore.RESET did not reset style of LIGHT_EX colors. Fixed by Andy Neff * Fix issue #51 - add context manager syntax. Thanks to Matt Olsen. * Fix issue #48 - colorama didn't work on Windows when environment variable 'TERM' was set. * Fix issue #54 - fix pylint errors in client code. * Changes to readme and other improvements by Marc Abramowitz and Zearin 0.3.3 * Fix Google Code issue #13 - support changing the console title with OSC escape sequence * Fix Google Code issue #16 - Add support for Windows xterm emulators * Fix Google Code issue #30 - implement \033[nK (clear line) * Fix Google Code issue #49 - no need to adjust for scroll when new position is already relative (CSI n A\B\C\D) * Fix Google Code issue #55 - erase_data fails on Python 3.x * Fix Google Code issue #46 - win32.COORD definition missing * Implement \033[0J and \033[1J (clear screen options) * Fix default ANSI parameters * Fix position after \033[2J (clear screen) * Add command shortcuts: colorama.Cursor, colorama.ansi.set_title, colorama.ansi.clear_line, colorama.ansi.clear_screen * Fix issue #22 - Importing fails for python3 on Windows * Thanks to John Szakmeister for adding support for light colors * Thanks to Charles Merriam for adding documentation to demos 0.3.2 * Thanks to Marc Schlaich (schlamar) for a setup.py fix for Python2.5 * Thanks to Jurko for fix on 64-bit Windows CPython2.5 w/o ctypes (Google Code issue #56) * Thanks to Remi Rampin for: * better github integration, incl rendered README and Travis config. * fixed forward slashes in README * Thanks to Florian Bruhin for fix when stdout or stderr are None * Thanks to Simeon Visser for: * closing a file handle using 'with' * updating classifiers to include Python 3.3 and 3.4 * Thanks to Thomas Weininger for fix ValueError on Windows (Google Code issue #50) 0.3.1 * Fixed crash on exit with closed stdout, with thanks to Marc Abramowitz. * Now uses setuptools if available, and falls back to distutils if not. * setup.py no longer imports anything from colorama source. 0.3.0 * Move repository to Git, https://github.com/tartley/colorama. (My Mercurial repo seemed to be corrupted, I couldn't commit nor view patches of old commits, even on fresh checkouts.) * Fix always-crash on non-Windows platforms, reported by Matt McCormick. * Fix Google Code issue #47, incompatible with pyreadline. 0.2.7 * Fix problem under 64-bit windows due to ctypes HANDLE size. Submitted by the rather magnificent Ben Hoyt. This fixes Google Code issue #43 0.2.6 * Add copyright & licensing info to every file, as requested by a large downstream project which has problems making sure that all 3rd party contributions have appropriate license. 0.2.5 * Severeral documentation & demo fixes. 0.2.4 * Fix to work on Windows 7. * Python 3 compatibility in docs and demos. * Add handling for 'cursor up' and 'get position' ANSI codes. 0.2.3 * Split changelog out into separate file. 0.2.2 * Fix bug which caused init() to raise, introduced in 0.2.1. * Remove asserts which cause problems in various circumstances. At least some users saw asserts fail on 'success' returned from win32 functions, even though the win32 functions appear to have worked correctly. 0.2.1 * Completely broken: I added a bug which caused init() to raise. * Added some documentation for cursor positioning and clear screen to README. * Add 'reinit' and 'deinit' functions, as suggested by Charles FOL and Romanov DA. 0.2 * Merge in changes from Daniel Griffith: Add ANSI cursor positioning & partial support for clear screen. Patch submitted by Oscar Lester, don't send RESET_ALL to non-tty. * Demos split into separate files and moved into their own directory. * Tweak sys.path in demos so they run against local source, not installed version of Colorama. 0.1.18 * Fix README (no such attr as Fore.DEFAULT, etc), kindly reported by nodakai. 0.1.17 * Prevent printing of garbage ANSI codes upon installing with pip 0.1.16 * Re-upload to fix previous error. Make clean now removes old MANIFEST. 0.1.15 * Completely broken. Distribution was empty due to leftover invalid MANIFEST file from building on a different platform. * Fix python3 incompatibility kindly reported by G |uumlaut| nter Kolousek 0.1.14 * Fix hard-coded reset to white-on-black colors. Fore.RESET, Back.RESET and Style.RESET_ALL now revert to the colors as they were when init() was called. Some lessons hopefully learned about testing prior to release. 0.1.13 * Completely broken: barfed when installed using pip. 0.1.12 * Completely broken: contained no source code. double oops. 0.1.11 * Completely broken: fatal import errors on Ubuntu. oops. 0.1.10 * Stop emulating 'bright' text with bright backgrounds. * Display 'normal' text using win32 normal foreground instead of bright. * Drop support for 'dim' text. 0.1.9 * Fix incompatibility with Python 2.5 and earlier. * Remove setup.py dependency on setuptools, now uses stdlib distutils. 0.1.8 * Fix ghastly errors all over the place on Ubuntu. * Add init kwargs 'convert' and 'strip', which supercede the old 'wrap'. 0.1.7 * Python 3 compatible. * Fix: Now strips ansi on windows without necessarily converting it to win32 calls (eg. if output is not a tty.) * Fix: Flaky interaction of interleaved ansi sent to stdout and stderr. * Improved demo.sh (hg checkout only.) 0.1.6 * Fix ansi sequences with no params now default to parmlist of [0]. * Fix flaky behaviour of autoreset and reset_all atexit. * Fix stacking of repeated atexit calls - now just called once. * Fix ghastly import problems while running tests. * 'demo.py' (hg checkout only) now demonstrates autoreset and reset atexit. * Provide colorama.VERSION, used by setup.py. * Tests defanged so they no longer actually change terminal color when run. 0.1.5 * Now works on Ubuntu. 0.1.4 * Implemented RESET_ALL on application exit 0.1.3 * Implemented init(wrap=False) 0.1.2 * Implemented init(autoreset=True) 0.1.1 * Minor tidy 0.1 * Works on Windows for foreground color, background color, bright or dim .. |uumlaut| unicode:: U+00FC .. u with umlaut :trim: colorama-0.3.7/LICENSE.txt0000644000076600000240000000272412470605461015605 0ustar arnonystaff00000000000000Copyright (c) 2010 Jonathan Hartley All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the copyright holders, nor those of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. colorama-0.3.7/MANIFEST.in0000644000076600000240000000011312470605461015506 0ustar arnonystaff00000000000000include LICENSE.txt CHANGELOG.rst recursive-include demos *.py *.bat *.sh colorama-0.3.7/PKG-INFO0000644000076600000240000003676512667514340015076 0ustar arnonystaff00000000000000Metadata-Version: 1.1 Name: colorama Version: 0.3.7 Summary: Cross-platform colored terminal text. Home-page: https://github.com/tartley/colorama Author: Arnon Yaari Author-email: tartley@tartley.com License: BSD Description: .. image:: https://pypip.in/version/colorama/badge.svg :target: https://pypi.python.org/pypi/colorama/ :alt: Latest Version .. image:: https://travis-ci.org/tartley/colorama.svg?branch=master :target: https://travis-ci.org/tartley/colorama :alt: Build Status Download and docs: http://pypi.python.org/pypi/colorama Source code & Development: https://github.com/tartley/colorama Description =========== Makes ANSI escape character sequences (for producing colored terminal text and cursor positioning) work under MS Windows. ANSI escape character sequences have long been used to produce colored terminal text and cursor positioning on Unix and Macs. Colorama makes this work on Windows, too, by wrapping ``stdout``, stripping ANSI sequences it finds (which would appear as gobbledygook in the output), and converting them into the appropriate win32 calls to modify the state of the terminal. On other platforms, Colorama does nothing. Colorama also provides some shortcuts to help generate ANSI sequences but works fine in conjunction with any other ANSI sequence generation library, such as the venerable Termcolor (http://pypi.python.org/pypi/termcolor) or the fabulous Blessings (https://pypi.python.org/pypi/blessings). This has the upshot of providing a simple cross-platform API for printing colored terminal text from Python, and has the happy side-effect that existing applications or libraries which use ANSI sequences to produce colored output on Linux or Macs can now also work on Windows, simply by calling ``colorama.init()``. An alternative approach is to install ``ansi.sys`` on Windows machines, which provides the same behaviour for all applications running in terminals. Colorama is intended for situations where that isn't easy (e.g., maybe your app doesn't have an installer.) Demo scripts in the source code repository print some colored text using ANSI sequences. Compare their output under Gnome-terminal's built in ANSI handling, versus on Windows Command-Prompt using Colorama: .. image:: https://github.com/tartley/colorama/raw/master/screenshots/ubuntu-demo.png :width: 661 :height: 357 :alt: ANSI sequences on Ubuntu under gnome-terminal. .. image:: https://github.com/tartley/colorama/raw/master/screenshots/windows-demo.png :width: 668 :height: 325 :alt: Same ANSI sequences on Windows, using Colorama. These screengrabs show that, on Windows, Colorama does not support ANSI 'dim text'; it looks the same as 'normal text'. License ======= Copyright Jonathan Hartley 2013. BSD 3-Clause license; see LICENSE file. Dependencies ============ None, other than Python. Tested on Python 2.5.5, 2.6.5, 2.7, 3.1.2, 3.2, 3.3, 3.4 and 3.5. Usage ===== Initialisation -------------- Applications should initialise Colorama using: .. code-block:: python from colorama import init init() On Windows, calling ``init()`` will filter ANSI escape sequences out of any text sent to ``stdout`` or ``stderr``, and replace them with equivalent Win32 calls. On other platforms, calling ``init()`` has no effect (unless you request other optional functionality; see "Init Keyword Args", below). By design, this permits applications to call ``init()`` unconditionally on all platforms, after which ANSI output should just work. To stop using colorama before your program exits, simply call ``deinit()``. This will restore ``stdout`` and ``stderr`` to their original values, so that Colorama is disabled. To resume using Colorama again, call ``reinit()``; it is cheaper to calling ``init()`` again (but does the same thing). Colored Output -------------- Cross-platform printing of colored text can then be done using Colorama's constant shorthand for ANSI escape sequences: .. code-block:: python from colorama import Fore, Back, Style print(Fore.RED + 'some red text') print(Back.GREEN + 'and with a green background') print(Style.DIM + 'and in dim text') print(Style.RESET_ALL) print('back to normal now') ...or simply by manually printing ANSI sequences from your own code: .. code-block:: python print('\033[31m' + 'some red text') print('\033[30m') # and reset to default color ...or, Colorama can be used happily in conjunction with existing ANSI libraries such as Termcolor: .. code-block:: python from colorama import init from termcolor import colored # use Colorama to make Termcolor work on Windows too init() # then use Termcolor for all colored text output print(colored('Hello, World!', 'green', 'on_red')) Available formatting constants are:: Fore: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET. Back: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET. Style: DIM, NORMAL, BRIGHT, RESET_ALL ``Style.RESET_ALL`` resets foreground, background, and brightness. Colorama will perform this reset automatically on program exit. Cursor Positioning ------------------ ANSI codes to reposition the cursor are supported. See ``demos/demo06.py`` for an example of how to generate them. Init Keyword Args ----------------- ``init()`` accepts some ``**kwargs`` to override default behaviour. init(autoreset=False): If you find yourself repeatedly sending reset sequences to turn off color changes at the end of every print, then ``init(autoreset=True)`` will automate that: .. code-block:: python from colorama import init init(autoreset=True) print(Fore.RED + 'some red text') print('automatically back to default color again') init(strip=None): Pass ``True`` or ``False`` to override whether ansi codes should be stripped from the output. The default behaviour is to strip if on Windows or if output is redirected (not a tty). init(convert=None): Pass ``True`` or ``False`` to override whether to convert ANSI codes in the output into win32 calls. The default behaviour is to convert if on Windows and output is to a tty (terminal). init(wrap=True): On Windows, colorama works by replacing ``sys.stdout`` and ``sys.stderr`` with proxy objects, which override the ``.write()`` method to do their work. If this wrapping causes you problems, then this can be disabled by passing ``init(wrap=False)``. The default behaviour is to wrap if ``autoreset`` or ``strip`` or ``convert`` are True. When wrapping is disabled, colored printing on non-Windows platforms will continue to work as normal. To do cross-platform colored output, you can use Colorama's ``AnsiToWin32`` proxy directly: .. code-block:: python import sys from colorama import init, AnsiToWin32 init(wrap=False) stream = AnsiToWin32(sys.stderr).stream # Python 2 print >>stream, Fore.BLUE + 'blue text on stderr' # Python 3 print(Fore.BLUE + 'blue text on stderr', file=stream) Status & Known Problems ======================= I've personally only tested it on Windows XP (CMD, Console2), Ubuntu (gnome-terminal, xterm), and OS X. Some presumably valid ANSI sequences aren't recognised (see details below), but to my knowledge nobody has yet complained about this. Puzzling. See outstanding issues and wishlist: https://github.com/tartley/colorama/issues If anything doesn't work for you, or doesn't do what you expected or hoped for, I'd love to hear about it on that issues list, would be delighted by patches, and would be happy to grant commit access to anyone who submits a working patch or two. Recognised ANSI Sequences ========================= ANSI sequences generally take the form: ESC [ ; ... Where ```` is an integer, and ```` is a single letter. Zero or more params are passed to a ````. If no params are passed, it is generally synonymous with passing a single zero. No spaces exist in the sequence; they have been inserted here simply to read more easily. The only ANSI sequences that colorama converts into win32 calls are:: ESC [ 0 m # reset all (colors and brightness) ESC [ 1 m # bright ESC [ 2 m # dim (looks same as normal brightness) ESC [ 22 m # normal brightness # FOREGROUND: ESC [ 30 m # black ESC [ 31 m # red ESC [ 32 m # green ESC [ 33 m # yellow ESC [ 34 m # blue ESC [ 35 m # magenta ESC [ 36 m # cyan ESC [ 37 m # white ESC [ 39 m # reset # BACKGROUND ESC [ 40 m # black ESC [ 41 m # red ESC [ 42 m # green ESC [ 43 m # yellow ESC [ 44 m # blue ESC [ 45 m # magenta ESC [ 46 m # cyan ESC [ 47 m # white ESC [ 49 m # reset # cursor positioning ESC [ y;x H # position cursor at x across, y down ESC [ y;x f # position cursor at x across, y down ESC [ n A # move cursor n lines up ESC [ n B # move cursor n lines down ESC [ n C # move cursor n characters forward ESC [ n D # move cursor n characters backward # clear the screen ESC [ mode J # clear the screen # clear the line ESC [ mode K # clear the line Multiple numeric params to the ``'m'`` command can be combined into a single sequence:: ESC [ 36 ; 45 ; 1 m # bright cyan text on magenta background All other ANSI sequences of the form ``ESC [ ; ... `` are silently stripped from the output on Windows. Any other form of ANSI sequence, such as single-character codes or alternative initial characters, are not recognised or stripped. It would be cool to add them though. Let me know if it would be useful for you, via the Issues on GitHub. Development =========== Help and fixes welcome! Running tests requires: - Michael Foord's ``mock`` module to be installed. - Tests are written using 2010-era updates to ``unittest``, and require Python 2.7 or greater, OR to have Michael Foord's ``unittest2`` module installed. To run tests:: python -m unittest discover -p *_test.py This, like a few other handy commands, is captured in a ``Makefile``. If you use nose to run the tests, you must pass the ``-s`` flag; otherwise, ``nosetests`` applies its own proxy to ``stdout``, which confuses the unit tests. Thanks ====== * Marc Schlaich (schlamar) for a ``setup.py`` fix for Python2.5. * Marc Abramowitz, reported & fixed a crash on exit with closed ``stdout``, providing a solution to issue #7's setuptools/distutils debate, and other fixes. * User 'eryksun', for guidance on correctly instantiating ``ctypes.windll``. * Matthew McCormick for politely pointing out a longstanding crash on non-Win. * Ben Hoyt, for a magnificent fix under 64-bit Windows. * Jesse at Empty Square for submitting a fix for examples in the README. * User 'jamessp', an observant documentation fix for cursor positioning. * User 'vaal1239', Dave Mckee & Lackner Kristof for a tiny but much-needed Win7 fix. * Julien Stuyck, for wisely suggesting Python3 compatible updates to README. * Daniel Griffith for multiple fabulous patches. * Oscar Lesta for a valuable fix to stop ANSI chars being sent to non-tty output. * Roger Binns, for many suggestions, valuable feedback, & bug reports. * Tim Golden for thought and much appreciated feedback on the initial idea. * User 'Zearin' for updates to the README file. * John Szakmeister for adding support for light colors * Charles Merriam for adding documentation to demos * Jurko for a fix on 64-bit Windows CPython2.5 w/o ctypes * Florian Bruhin for a fix when stdout or stderr are None * Thomas Weininger for fixing ValueError on Windows * Remi Rampin for better Github integration and fixes to the README file * Simeon Visser for closing a file handle using 'with' and updating classifiers to include Python 3.3 and 3.4 * Andy Neff for fixing RESET of LIGHT_EX colors. * Jonathan Hartley for the initial idea and implementation. Keywords: color colour terminal text ansi windows crossplatform xplatform Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Console Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: BSD License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.5 Classifier: Programming Language :: Python :: 2.6 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.1 Classifier: Programming Language :: Python :: 3.2 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Topic :: Terminals colorama-0.3.7/README.rst0000644000076600000240000002735612630136254015456 0ustar arnonystaff00000000000000.. image:: https://pypip.in/version/colorama/badge.svg :target: https://pypi.python.org/pypi/colorama/ :alt: Latest Version .. image:: https://travis-ci.org/tartley/colorama.svg?branch=master :target: https://travis-ci.org/tartley/colorama :alt: Build Status Download and docs: http://pypi.python.org/pypi/colorama Source code & Development: https://github.com/tartley/colorama Description =========== Makes ANSI escape character sequences (for producing colored terminal text and cursor positioning) work under MS Windows. ANSI escape character sequences have long been used to produce colored terminal text and cursor positioning on Unix and Macs. Colorama makes this work on Windows, too, by wrapping ``stdout``, stripping ANSI sequences it finds (which would appear as gobbledygook in the output), and converting them into the appropriate win32 calls to modify the state of the terminal. On other platforms, Colorama does nothing. Colorama also provides some shortcuts to help generate ANSI sequences but works fine in conjunction with any other ANSI sequence generation library, such as the venerable Termcolor (http://pypi.python.org/pypi/termcolor) or the fabulous Blessings (https://pypi.python.org/pypi/blessings). This has the upshot of providing a simple cross-platform API for printing colored terminal text from Python, and has the happy side-effect that existing applications or libraries which use ANSI sequences to produce colored output on Linux or Macs can now also work on Windows, simply by calling ``colorama.init()``. An alternative approach is to install ``ansi.sys`` on Windows machines, which provides the same behaviour for all applications running in terminals. Colorama is intended for situations where that isn't easy (e.g., maybe your app doesn't have an installer.) Demo scripts in the source code repository print some colored text using ANSI sequences. Compare their output under Gnome-terminal's built in ANSI handling, versus on Windows Command-Prompt using Colorama: .. image:: https://github.com/tartley/colorama/raw/master/screenshots/ubuntu-demo.png :width: 661 :height: 357 :alt: ANSI sequences on Ubuntu under gnome-terminal. .. image:: https://github.com/tartley/colorama/raw/master/screenshots/windows-demo.png :width: 668 :height: 325 :alt: Same ANSI sequences on Windows, using Colorama. These screengrabs show that, on Windows, Colorama does not support ANSI 'dim text'; it looks the same as 'normal text'. License ======= Copyright Jonathan Hartley 2013. BSD 3-Clause license; see LICENSE file. Dependencies ============ None, other than Python. Tested on Python 2.5.5, 2.6.5, 2.7, 3.1.2, 3.2, 3.3, 3.4 and 3.5. Usage ===== Initialisation -------------- Applications should initialise Colorama using: .. code-block:: python from colorama import init init() On Windows, calling ``init()`` will filter ANSI escape sequences out of any text sent to ``stdout`` or ``stderr``, and replace them with equivalent Win32 calls. On other platforms, calling ``init()`` has no effect (unless you request other optional functionality; see "Init Keyword Args", below). By design, this permits applications to call ``init()`` unconditionally on all platforms, after which ANSI output should just work. To stop using colorama before your program exits, simply call ``deinit()``. This will restore ``stdout`` and ``stderr`` to their original values, so that Colorama is disabled. To resume using Colorama again, call ``reinit()``; it is cheaper to calling ``init()`` again (but does the same thing). Colored Output -------------- Cross-platform printing of colored text can then be done using Colorama's constant shorthand for ANSI escape sequences: .. code-block:: python from colorama import Fore, Back, Style print(Fore.RED + 'some red text') print(Back.GREEN + 'and with a green background') print(Style.DIM + 'and in dim text') print(Style.RESET_ALL) print('back to normal now') ...or simply by manually printing ANSI sequences from your own code: .. code-block:: python print('\033[31m' + 'some red text') print('\033[30m') # and reset to default color ...or, Colorama can be used happily in conjunction with existing ANSI libraries such as Termcolor: .. code-block:: python from colorama import init from termcolor import colored # use Colorama to make Termcolor work on Windows too init() # then use Termcolor for all colored text output print(colored('Hello, World!', 'green', 'on_red')) Available formatting constants are:: Fore: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET. Back: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET. Style: DIM, NORMAL, BRIGHT, RESET_ALL ``Style.RESET_ALL`` resets foreground, background, and brightness. Colorama will perform this reset automatically on program exit. Cursor Positioning ------------------ ANSI codes to reposition the cursor are supported. See ``demos/demo06.py`` for an example of how to generate them. Init Keyword Args ----------------- ``init()`` accepts some ``**kwargs`` to override default behaviour. init(autoreset=False): If you find yourself repeatedly sending reset sequences to turn off color changes at the end of every print, then ``init(autoreset=True)`` will automate that: .. code-block:: python from colorama import init init(autoreset=True) print(Fore.RED + 'some red text') print('automatically back to default color again') init(strip=None): Pass ``True`` or ``False`` to override whether ansi codes should be stripped from the output. The default behaviour is to strip if on Windows or if output is redirected (not a tty). init(convert=None): Pass ``True`` or ``False`` to override whether to convert ANSI codes in the output into win32 calls. The default behaviour is to convert if on Windows and output is to a tty (terminal). init(wrap=True): On Windows, colorama works by replacing ``sys.stdout`` and ``sys.stderr`` with proxy objects, which override the ``.write()`` method to do their work. If this wrapping causes you problems, then this can be disabled by passing ``init(wrap=False)``. The default behaviour is to wrap if ``autoreset`` or ``strip`` or ``convert`` are True. When wrapping is disabled, colored printing on non-Windows platforms will continue to work as normal. To do cross-platform colored output, you can use Colorama's ``AnsiToWin32`` proxy directly: .. code-block:: python import sys from colorama import init, AnsiToWin32 init(wrap=False) stream = AnsiToWin32(sys.stderr).stream # Python 2 print >>stream, Fore.BLUE + 'blue text on stderr' # Python 3 print(Fore.BLUE + 'blue text on stderr', file=stream) Status & Known Problems ======================= I've personally only tested it on Windows XP (CMD, Console2), Ubuntu (gnome-terminal, xterm), and OS X. Some presumably valid ANSI sequences aren't recognised (see details below), but to my knowledge nobody has yet complained about this. Puzzling. See outstanding issues and wishlist: https://github.com/tartley/colorama/issues If anything doesn't work for you, or doesn't do what you expected or hoped for, I'd love to hear about it on that issues list, would be delighted by patches, and would be happy to grant commit access to anyone who submits a working patch or two. Recognised ANSI Sequences ========================= ANSI sequences generally take the form: ESC [ ; ... Where ```` is an integer, and ```` is a single letter. Zero or more params are passed to a ````. If no params are passed, it is generally synonymous with passing a single zero. No spaces exist in the sequence; they have been inserted here simply to read more easily. The only ANSI sequences that colorama converts into win32 calls are:: ESC [ 0 m # reset all (colors and brightness) ESC [ 1 m # bright ESC [ 2 m # dim (looks same as normal brightness) ESC [ 22 m # normal brightness # FOREGROUND: ESC [ 30 m # black ESC [ 31 m # red ESC [ 32 m # green ESC [ 33 m # yellow ESC [ 34 m # blue ESC [ 35 m # magenta ESC [ 36 m # cyan ESC [ 37 m # white ESC [ 39 m # reset # BACKGROUND ESC [ 40 m # black ESC [ 41 m # red ESC [ 42 m # green ESC [ 43 m # yellow ESC [ 44 m # blue ESC [ 45 m # magenta ESC [ 46 m # cyan ESC [ 47 m # white ESC [ 49 m # reset # cursor positioning ESC [ y;x H # position cursor at x across, y down ESC [ y;x f # position cursor at x across, y down ESC [ n A # move cursor n lines up ESC [ n B # move cursor n lines down ESC [ n C # move cursor n characters forward ESC [ n D # move cursor n characters backward # clear the screen ESC [ mode J # clear the screen # clear the line ESC [ mode K # clear the line Multiple numeric params to the ``'m'`` command can be combined into a single sequence:: ESC [ 36 ; 45 ; 1 m # bright cyan text on magenta background All other ANSI sequences of the form ``ESC [ ; ... `` are silently stripped from the output on Windows. Any other form of ANSI sequence, such as single-character codes or alternative initial characters, are not recognised or stripped. It would be cool to add them though. Let me know if it would be useful for you, via the Issues on GitHub. Development =========== Help and fixes welcome! Running tests requires: - Michael Foord's ``mock`` module to be installed. - Tests are written using 2010-era updates to ``unittest``, and require Python 2.7 or greater, OR to have Michael Foord's ``unittest2`` module installed. To run tests:: python -m unittest discover -p *_test.py This, like a few other handy commands, is captured in a ``Makefile``. If you use nose to run the tests, you must pass the ``-s`` flag; otherwise, ``nosetests`` applies its own proxy to ``stdout``, which confuses the unit tests. Thanks ====== * Marc Schlaich (schlamar) for a ``setup.py`` fix for Python2.5. * Marc Abramowitz, reported & fixed a crash on exit with closed ``stdout``, providing a solution to issue #7's setuptools/distutils debate, and other fixes. * User 'eryksun', for guidance on correctly instantiating ``ctypes.windll``. * Matthew McCormick for politely pointing out a longstanding crash on non-Win. * Ben Hoyt, for a magnificent fix under 64-bit Windows. * Jesse at Empty Square for submitting a fix for examples in the README. * User 'jamessp', an observant documentation fix for cursor positioning. * User 'vaal1239', Dave Mckee & Lackner Kristof for a tiny but much-needed Win7 fix. * Julien Stuyck, for wisely suggesting Python3 compatible updates to README. * Daniel Griffith for multiple fabulous patches. * Oscar Lesta for a valuable fix to stop ANSI chars being sent to non-tty output. * Roger Binns, for many suggestions, valuable feedback, & bug reports. * Tim Golden for thought and much appreciated feedback on the initial idea. * User 'Zearin' for updates to the README file. * John Szakmeister for adding support for light colors * Charles Merriam for adding documentation to demos * Jurko for a fix on 64-bit Windows CPython2.5 w/o ctypes * Florian Bruhin for a fix when stdout or stderr are None * Thomas Weininger for fixing ValueError on Windows * Remi Rampin for better Github integration and fixes to the README file * Simeon Visser for closing a file handle using 'with' and updating classifiers to include Python 3.3 and 3.4 * Andy Neff for fixing RESET of LIGHT_EX colors. * Jonathan Hartley for the initial idea and implementation. colorama-0.3.7/colorama/0000755000076600000240000000000012667514340015555 5ustar arnonystaff00000000000000colorama-0.3.7/colorama/__init__.py0000644000076600000240000000036012667514005017663 0ustar arnonystaff00000000000000# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. from .initialise import init, deinit, reinit, colorama_text from .ansi import Fore, Back, Style, Cursor from .ansitowin32 import AnsiToWin32 __version__ = '0.3.7' colorama-0.3.7/colorama/ansi.py0000644000076600000240000000473412600754354017067 0ustar arnonystaff00000000000000# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. ''' This module generates ANSI character codes to printing colors to terminals. See: http://en.wikipedia.org/wiki/ANSI_escape_code ''' CSI = '\033[' OSC = '\033]' BEL = '\007' def code_to_chars(code): return CSI + str(code) + 'm' def set_title(title): return OSC + '2;' + title + BEL def clear_screen(mode=2): return CSI + str(mode) + 'J' def clear_line(mode=2): return CSI + str(mode) + 'K' class AnsiCodes(object): def __init__(self): # the subclasses declare class attributes which are numbers. # Upon instantiation we define instance attributes, which are the same # as the class attributes but wrapped with the ANSI escape sequence for name in dir(self): if not name.startswith('_'): value = getattr(self, name) setattr(self, name, code_to_chars(value)) class AnsiCursor(object): def UP(self, n=1): return CSI + str(n) + 'A' def DOWN(self, n=1): return CSI + str(n) + 'B' def FORWARD(self, n=1): return CSI + str(n) + 'C' def BACK(self, n=1): return CSI + str(n) + 'D' def POS(self, x=1, y=1): return CSI + str(y) + ';' + str(x) + 'H' class AnsiFore(AnsiCodes): BLACK = 30 RED = 31 GREEN = 32 YELLOW = 33 BLUE = 34 MAGENTA = 35 CYAN = 36 WHITE = 37 RESET = 39 # These are fairly well supported, but not part of the standard. LIGHTBLACK_EX = 90 LIGHTRED_EX = 91 LIGHTGREEN_EX = 92 LIGHTYELLOW_EX = 93 LIGHTBLUE_EX = 94 LIGHTMAGENTA_EX = 95 LIGHTCYAN_EX = 96 LIGHTWHITE_EX = 97 class AnsiBack(AnsiCodes): BLACK = 40 RED = 41 GREEN = 42 YELLOW = 43 BLUE = 44 MAGENTA = 45 CYAN = 46 WHITE = 47 RESET = 49 # These are fairly well supported, but not part of the standard. LIGHTBLACK_EX = 100 LIGHTRED_EX = 101 LIGHTGREEN_EX = 102 LIGHTYELLOW_EX = 103 LIGHTBLUE_EX = 104 LIGHTMAGENTA_EX = 105 LIGHTCYAN_EX = 106 LIGHTWHITE_EX = 107 class AnsiStyle(AnsiCodes): BRIGHT = 1 DIM = 2 NORMAL = 22 RESET_ALL = 0 Fore = AnsiFore() Back = AnsiBack() Style = AnsiStyle() Cursor = AnsiCursor() colorama-0.3.7/colorama/ansitowin32.py0000644000076600000240000002270412657060066020314 0ustar arnonystaff00000000000000# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. import re import sys import os from .ansi import AnsiFore, AnsiBack, AnsiStyle, Style from .winterm import WinTerm, WinColor, WinStyle from .win32 import windll, winapi_test winterm = None if windll is not None: winterm = WinTerm() def is_stream_closed(stream): return not hasattr(stream, 'closed') or stream.closed def is_a_tty(stream): return hasattr(stream, 'isatty') and stream.isatty() class StreamWrapper(object): ''' Wraps a stream (such as stdout), acting as a transparent proxy for all attribute access apart from method 'write()', which is delegated to our Converter instance. ''' def __init__(self, wrapped, converter): # double-underscore everything to prevent clashes with names of # attributes on the wrapped stream object. self.__wrapped = wrapped self.__convertor = converter def __getattr__(self, name): return getattr(self.__wrapped, name) def write(self, text): self.__convertor.write(text) class AnsiToWin32(object): ''' Implements a 'write()' method which, on Windows, will strip ANSI character sequences from the text, and if outputting to a tty, will convert them into win32 function calls. ''' ANSI_CSI_RE = re.compile('\001?\033\[((?:\d|;)*)([a-zA-Z])\002?') # Control Sequence Introducer ANSI_OSC_RE = re.compile('\001?\033\]((?:.|;)*?)(\x07)\002?') # Operating System Command def __init__(self, wrapped, convert=None, strip=None, autoreset=False): # The wrapped stream (normally sys.stdout or sys.stderr) self.wrapped = wrapped # should we reset colors to defaults after every .write() self.autoreset = autoreset # create the proxy wrapping our output stream self.stream = StreamWrapper(wrapped, self) on_windows = os.name == 'nt' # We test if the WinAPI works, because even if we are on Windows # we may be using a terminal that doesn't support the WinAPI # (e.g. Cygwin Terminal). In this case it's up to the terminal # to support the ANSI codes. conversion_supported = on_windows and winapi_test() # should we strip ANSI sequences from our output? if strip is None: strip = conversion_supported or (not is_stream_closed(wrapped) and not is_a_tty(wrapped)) self.strip = strip # should we should convert ANSI sequences into win32 calls? if convert is None: convert = conversion_supported and not is_stream_closed(wrapped) and is_a_tty(wrapped) self.convert = convert # dict of ansi codes to win32 functions and parameters self.win32_calls = self.get_win32_calls() # are we wrapping stderr? self.on_stderr = self.wrapped is sys.stderr def should_wrap(self): ''' True if this class is actually needed. If false, then the output stream will not be affected, nor will win32 calls be issued, so wrapping stdout is not actually required. This will generally be False on non-Windows platforms, unless optional functionality like autoreset has been requested using kwargs to init() ''' return self.convert or self.strip or self.autoreset def get_win32_calls(self): if self.convert and winterm: return { AnsiStyle.RESET_ALL: (winterm.reset_all, ), AnsiStyle.BRIGHT: (winterm.style, WinStyle.BRIGHT), AnsiStyle.DIM: (winterm.style, WinStyle.NORMAL), AnsiStyle.NORMAL: (winterm.style, WinStyle.NORMAL), AnsiFore.BLACK: (winterm.fore, WinColor.BLACK), AnsiFore.RED: (winterm.fore, WinColor.RED), AnsiFore.GREEN: (winterm.fore, WinColor.GREEN), AnsiFore.YELLOW: (winterm.fore, WinColor.YELLOW), AnsiFore.BLUE: (winterm.fore, WinColor.BLUE), AnsiFore.MAGENTA: (winterm.fore, WinColor.MAGENTA), AnsiFore.CYAN: (winterm.fore, WinColor.CYAN), AnsiFore.WHITE: (winterm.fore, WinColor.GREY), AnsiFore.RESET: (winterm.fore, ), AnsiFore.LIGHTBLACK_EX: (winterm.fore, WinColor.BLACK, True), AnsiFore.LIGHTRED_EX: (winterm.fore, WinColor.RED, True), AnsiFore.LIGHTGREEN_EX: (winterm.fore, WinColor.GREEN, True), AnsiFore.LIGHTYELLOW_EX: (winterm.fore, WinColor.YELLOW, True), AnsiFore.LIGHTBLUE_EX: (winterm.fore, WinColor.BLUE, True), AnsiFore.LIGHTMAGENTA_EX: (winterm.fore, WinColor.MAGENTA, True), AnsiFore.LIGHTCYAN_EX: (winterm.fore, WinColor.CYAN, True), AnsiFore.LIGHTWHITE_EX: (winterm.fore, WinColor.GREY, True), AnsiBack.BLACK: (winterm.back, WinColor.BLACK), AnsiBack.RED: (winterm.back, WinColor.RED), AnsiBack.GREEN: (winterm.back, WinColor.GREEN), AnsiBack.YELLOW: (winterm.back, WinColor.YELLOW), AnsiBack.BLUE: (winterm.back, WinColor.BLUE), AnsiBack.MAGENTA: (winterm.back, WinColor.MAGENTA), AnsiBack.CYAN: (winterm.back, WinColor.CYAN), AnsiBack.WHITE: (winterm.back, WinColor.GREY), AnsiBack.RESET: (winterm.back, ), AnsiBack.LIGHTBLACK_EX: (winterm.back, WinColor.BLACK, True), AnsiBack.LIGHTRED_EX: (winterm.back, WinColor.RED, True), AnsiBack.LIGHTGREEN_EX: (winterm.back, WinColor.GREEN, True), AnsiBack.LIGHTYELLOW_EX: (winterm.back, WinColor.YELLOW, True), AnsiBack.LIGHTBLUE_EX: (winterm.back, WinColor.BLUE, True), AnsiBack.LIGHTMAGENTA_EX: (winterm.back, WinColor.MAGENTA, True), AnsiBack.LIGHTCYAN_EX: (winterm.back, WinColor.CYAN, True), AnsiBack.LIGHTWHITE_EX: (winterm.back, WinColor.GREY, True), } return dict() def write(self, text): if self.strip or self.convert: self.write_and_convert(text) else: self.wrapped.write(text) self.wrapped.flush() if self.autoreset: self.reset_all() def reset_all(self): if self.convert: self.call_win32('m', (0,)) elif not self.strip and not is_stream_closed(self.wrapped): self.wrapped.write(Style.RESET_ALL) def write_and_convert(self, text): ''' Write the given text to our wrapped stream, stripping any ANSI sequences from the text, and optionally converting them into win32 calls. ''' cursor = 0 text = self.convert_osc(text) for match in self.ANSI_CSI_RE.finditer(text): start, end = match.span() self.write_plain_text(text, cursor, start) self.convert_ansi(*match.groups()) cursor = end self.write_plain_text(text, cursor, len(text)) def write_plain_text(self, text, start, end): if start < end: self.wrapped.write(text[start:end]) self.wrapped.flush() def convert_ansi(self, paramstring, command): if self.convert: params = self.extract_params(command, paramstring) self.call_win32(command, params) def extract_params(self, command, paramstring): if command in 'Hf': params = tuple(int(p) if len(p) != 0 else 1 for p in paramstring.split(';')) while len(params) < 2: # defaults: params = params + (1,) else: params = tuple(int(p) for p in paramstring.split(';') if len(p) != 0) if len(params) == 0: # defaults: if command in 'JKm': params = (0,) elif command in 'ABCD': params = (1,) return params def call_win32(self, command, params): if command == 'm': for param in params: if param in self.win32_calls: func_args = self.win32_calls[param] func = func_args[0] args = func_args[1:] kwargs = dict(on_stderr=self.on_stderr) func(*args, **kwargs) elif command in 'J': winterm.erase_screen(params[0], on_stderr=self.on_stderr) elif command in 'K': winterm.erase_line(params[0], on_stderr=self.on_stderr) elif command in 'Hf': # cursor position - absolute winterm.set_cursor_position(params, on_stderr=self.on_stderr) elif command in 'ABCD': # cursor position - relative n = params[0] # A - up, B - down, C - forward, D - back x, y = {'A': (0, -n), 'B': (0, n), 'C': (n, 0), 'D': (-n, 0)}[command] winterm.cursor_adjust(x, y, on_stderr=self.on_stderr) def convert_osc(self, text): for match in self.ANSI_OSC_RE.finditer(text): start, end = match.span() text = text[:start] + text[end:] paramstring, command = match.groups() if command in '\x07': # \x07 = BEL params = paramstring.split(";") # 0 - change title and icon (we will only change title) # 1 - change icon (we don't support this) # 2 - change title if params[0] in '02': winterm.set_title(params[1]) return text colorama-0.3.7/colorama/initialise.py0000644000076600000240000000357512657060060020265 0ustar arnonystaff00000000000000# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. import atexit import contextlib import sys from .ansitowin32 import AnsiToWin32 orig_stdout = None orig_stderr = None wrapped_stdout = None wrapped_stderr = None atexit_done = False def reset_all(): if AnsiToWin32 is not None: # Issue #74: objects might become None at exit AnsiToWin32(orig_stdout).reset_all() def init(autoreset=False, convert=None, strip=None, wrap=True): if not wrap and any([autoreset, convert, strip]): raise ValueError('wrap=False conflicts with any other arg=True') global wrapped_stdout, wrapped_stderr global orig_stdout, orig_stderr orig_stdout = sys.stdout orig_stderr = sys.stderr if sys.stdout is None: wrapped_stdout = None else: sys.stdout = wrapped_stdout = \ wrap_stream(orig_stdout, convert, strip, autoreset, wrap) if sys.stderr is None: wrapped_stderr = None else: sys.stderr = wrapped_stderr = \ wrap_stream(orig_stderr, convert, strip, autoreset, wrap) global atexit_done if not atexit_done: atexit.register(reset_all) atexit_done = True def deinit(): if orig_stdout is not None: sys.stdout = orig_stdout if orig_stderr is not None: sys.stderr = orig_stderr @contextlib.contextmanager def colorama_text(*args, **kwargs): init(*args, **kwargs) try: yield finally: deinit() def reinit(): if wrapped_stdout is not None: sys.stdout = wrapped_stdout if wrapped_stderr is not None: sys.stderr = wrapped_stderr def wrap_stream(stream, convert, strip, autoreset, wrap): if wrap: wrapper = AnsiToWin32(stream, convert=convert, strip=strip, autoreset=autoreset) if wrapper.should_wrap(): stream = wrapper.stream return stream colorama-0.3.7/colorama/win32.py0000644000076600000240000001236512600756417017100 0ustar arnonystaff00000000000000# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. # from winbase.h STDOUT = -11 STDERR = -12 try: import ctypes from ctypes import LibraryLoader windll = LibraryLoader(ctypes.WinDLL) from ctypes import wintypes except (AttributeError, ImportError): windll = None SetConsoleTextAttribute = lambda *_: None winapi_test = lambda *_: None else: from ctypes import byref, Structure, c_char, POINTER COORD = wintypes._COORD class CONSOLE_SCREEN_BUFFER_INFO(Structure): """struct in wincon.h.""" _fields_ = [ ("dwSize", COORD), ("dwCursorPosition", COORD), ("wAttributes", wintypes.WORD), ("srWindow", wintypes.SMALL_RECT), ("dwMaximumWindowSize", COORD), ] def __str__(self): return '(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)' % ( self.dwSize.Y, self.dwSize.X , self.dwCursorPosition.Y, self.dwCursorPosition.X , self.wAttributes , self.srWindow.Top, self.srWindow.Left, self.srWindow.Bottom, self.srWindow.Right , self.dwMaximumWindowSize.Y, self.dwMaximumWindowSize.X ) _GetStdHandle = windll.kernel32.GetStdHandle _GetStdHandle.argtypes = [ wintypes.DWORD, ] _GetStdHandle.restype = wintypes.HANDLE _GetConsoleScreenBufferInfo = windll.kernel32.GetConsoleScreenBufferInfo _GetConsoleScreenBufferInfo.argtypes = [ wintypes.HANDLE, POINTER(CONSOLE_SCREEN_BUFFER_INFO), ] _GetConsoleScreenBufferInfo.restype = wintypes.BOOL _SetConsoleTextAttribute = windll.kernel32.SetConsoleTextAttribute _SetConsoleTextAttribute.argtypes = [ wintypes.HANDLE, wintypes.WORD, ] _SetConsoleTextAttribute.restype = wintypes.BOOL _SetConsoleCursorPosition = windll.kernel32.SetConsoleCursorPosition _SetConsoleCursorPosition.argtypes = [ wintypes.HANDLE, COORD, ] _SetConsoleCursorPosition.restype = wintypes.BOOL _FillConsoleOutputCharacterA = windll.kernel32.FillConsoleOutputCharacterA _FillConsoleOutputCharacterA.argtypes = [ wintypes.HANDLE, c_char, wintypes.DWORD, COORD, POINTER(wintypes.DWORD), ] _FillConsoleOutputCharacterA.restype = wintypes.BOOL _FillConsoleOutputAttribute = windll.kernel32.FillConsoleOutputAttribute _FillConsoleOutputAttribute.argtypes = [ wintypes.HANDLE, wintypes.WORD, wintypes.DWORD, COORD, POINTER(wintypes.DWORD), ] _FillConsoleOutputAttribute.restype = wintypes.BOOL _SetConsoleTitleW = windll.kernel32.SetConsoleTitleA _SetConsoleTitleW.argtypes = [ wintypes.LPCSTR ] _SetConsoleTitleW.restype = wintypes.BOOL handles = { STDOUT: _GetStdHandle(STDOUT), STDERR: _GetStdHandle(STDERR), } def winapi_test(): handle = handles[STDOUT] csbi = CONSOLE_SCREEN_BUFFER_INFO() success = _GetConsoleScreenBufferInfo( handle, byref(csbi)) return bool(success) def GetConsoleScreenBufferInfo(stream_id=STDOUT): handle = handles[stream_id] csbi = CONSOLE_SCREEN_BUFFER_INFO() success = _GetConsoleScreenBufferInfo( handle, byref(csbi)) return csbi def SetConsoleTextAttribute(stream_id, attrs): handle = handles[stream_id] return _SetConsoleTextAttribute(handle, attrs) def SetConsoleCursorPosition(stream_id, position, adjust=True): position = COORD(*position) # If the position is out of range, do nothing. if position.Y <= 0 or position.X <= 0: return # Adjust for Windows' SetConsoleCursorPosition: # 1. being 0-based, while ANSI is 1-based. # 2. expecting (x,y), while ANSI uses (y,x). adjusted_position = COORD(position.Y - 1, position.X - 1) if adjust: # Adjust for viewport's scroll position sr = GetConsoleScreenBufferInfo(STDOUT).srWindow adjusted_position.Y += sr.Top adjusted_position.X += sr.Left # Resume normal processing handle = handles[stream_id] return _SetConsoleCursorPosition(handle, adjusted_position) def FillConsoleOutputCharacter(stream_id, char, length, start): handle = handles[stream_id] char = c_char(char.encode()) length = wintypes.DWORD(length) num_written = wintypes.DWORD(0) # Note that this is hard-coded for ANSI (vs wide) bytes. success = _FillConsoleOutputCharacterA( handle, char, length, start, byref(num_written)) return num_written.value def FillConsoleOutputAttribute(stream_id, attr, length, start): ''' FillConsoleOutputAttribute( hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten )''' handle = handles[stream_id] attribute = wintypes.WORD(attr) length = wintypes.DWORD(length) num_written = wintypes.DWORD(0) # Note that this is hard-coded for ANSI (vs wide) bytes. return _FillConsoleOutputAttribute( handle, attribute, length, start, byref(num_written)) def SetConsoleTitle(title): return _SetConsoleTitleW(title) colorama-0.3.7/colorama/winterm.py0000644000076600000240000001422212561140173017605 0ustar arnonystaff00000000000000# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. from . import win32 # from wincon.h class WinColor(object): BLACK = 0 BLUE = 1 GREEN = 2 CYAN = 3 RED = 4 MAGENTA = 5 YELLOW = 6 GREY = 7 # from wincon.h class WinStyle(object): NORMAL = 0x00 # dim text, dim background BRIGHT = 0x08 # bright text, dim background BRIGHT_BACKGROUND = 0x80 # dim text, bright background class WinTerm(object): def __init__(self): self._default = win32.GetConsoleScreenBufferInfo(win32.STDOUT).wAttributes self.set_attrs(self._default) self._default_fore = self._fore self._default_back = self._back self._default_style = self._style # In order to emulate LIGHT_EX in windows, we borrow the BRIGHT style. # So that LIGHT_EX colors and BRIGHT style do not clobber each other, # we track them separately, since LIGHT_EX is overwritten by Fore/Back # and BRIGHT is overwritten by Style codes. self._light = 0 def get_attrs(self): return self._fore + self._back * 16 + (self._style | self._light) def set_attrs(self, value): self._fore = value & 7 self._back = (value >> 4) & 7 self._style = value & (WinStyle.BRIGHT | WinStyle.BRIGHT_BACKGROUND) def reset_all(self, on_stderr=None): self.set_attrs(self._default) self.set_console(attrs=self._default) def fore(self, fore=None, light=False, on_stderr=False): if fore is None: fore = self._default_fore self._fore = fore # Emulate LIGHT_EX with BRIGHT Style if light: self._light |= WinStyle.BRIGHT else: self._light &= ~WinStyle.BRIGHT self.set_console(on_stderr=on_stderr) def back(self, back=None, light=False, on_stderr=False): if back is None: back = self._default_back self._back = back # Emulate LIGHT_EX with BRIGHT_BACKGROUND Style if light: self._light |= WinStyle.BRIGHT_BACKGROUND else: self._light &= ~WinStyle.BRIGHT_BACKGROUND self.set_console(on_stderr=on_stderr) def style(self, style=None, on_stderr=False): if style is None: style = self._default_style self._style = style self.set_console(on_stderr=on_stderr) def set_console(self, attrs=None, on_stderr=False): if attrs is None: attrs = self.get_attrs() handle = win32.STDOUT if on_stderr: handle = win32.STDERR win32.SetConsoleTextAttribute(handle, attrs) def get_position(self, handle): position = win32.GetConsoleScreenBufferInfo(handle).dwCursorPosition # Because Windows coordinates are 0-based, # and win32.SetConsoleCursorPosition expects 1-based. position.X += 1 position.Y += 1 return position def set_cursor_position(self, position=None, on_stderr=False): if position is None: # I'm not currently tracking the position, so there is no default. # position = self.get_position() return handle = win32.STDOUT if on_stderr: handle = win32.STDERR win32.SetConsoleCursorPosition(handle, position) def cursor_adjust(self, x, y, on_stderr=False): handle = win32.STDOUT if on_stderr: handle = win32.STDERR position = self.get_position(handle) adjusted_position = (position.Y + y, position.X + x) win32.SetConsoleCursorPosition(handle, adjusted_position, adjust=False) def erase_screen(self, mode=0, on_stderr=False): # 0 should clear from the cursor to the end of the screen. # 1 should clear from the cursor to the beginning of the screen. # 2 should clear the entire screen, and move cursor to (1,1) handle = win32.STDOUT if on_stderr: handle = win32.STDERR csbi = win32.GetConsoleScreenBufferInfo(handle) # get the number of character cells in the current buffer cells_in_screen = csbi.dwSize.X * csbi.dwSize.Y # get number of character cells before current cursor position cells_before_cursor = csbi.dwSize.X * csbi.dwCursorPosition.Y + csbi.dwCursorPosition.X if mode == 0: from_coord = csbi.dwCursorPosition cells_to_erase = cells_in_screen - cells_before_cursor if mode == 1: from_coord = win32.COORD(0, 0) cells_to_erase = cells_before_cursor elif mode == 2: from_coord = win32.COORD(0, 0) cells_to_erase = cells_in_screen # fill the entire screen with blanks win32.FillConsoleOutputCharacter(handle, ' ', cells_to_erase, from_coord) # now set the buffer's attributes accordingly win32.FillConsoleOutputAttribute(handle, self.get_attrs(), cells_to_erase, from_coord) if mode == 2: # put the cursor where needed win32.SetConsoleCursorPosition(handle, (1, 1)) def erase_line(self, mode=0, on_stderr=False): # 0 should clear from the cursor to the end of the line. # 1 should clear from the cursor to the beginning of the line. # 2 should clear the entire line. handle = win32.STDOUT if on_stderr: handle = win32.STDERR csbi = win32.GetConsoleScreenBufferInfo(handle) if mode == 0: from_coord = csbi.dwCursorPosition cells_to_erase = csbi.dwSize.X - csbi.dwCursorPosition.X if mode == 1: from_coord = win32.COORD(0, csbi.dwCursorPosition.Y) cells_to_erase = csbi.dwCursorPosition.X elif mode == 2: from_coord = win32.COORD(0, csbi.dwCursorPosition.Y) cells_to_erase = csbi.dwSize.X # fill the entire screen with blanks win32.FillConsoleOutputCharacter(handle, ' ', cells_to_erase, from_coord) # now set the buffer's attributes accordingly win32.FillConsoleOutputAttribute(handle, self.get_attrs(), cells_to_erase, from_coord) def set_title(self, title): win32.SetConsoleTitle(title) colorama-0.3.7/colorama.egg-info/0000755000076600000240000000000012667514340017247 5ustar arnonystaff00000000000000colorama-0.3.7/colorama.egg-info/PKG-INFO0000644000076600000240000003676512667514340020365 0ustar arnonystaff00000000000000Metadata-Version: 1.1 Name: colorama Version: 0.3.7 Summary: Cross-platform colored terminal text. Home-page: https://github.com/tartley/colorama Author: Arnon Yaari Author-email: tartley@tartley.com License: BSD Description: .. image:: https://pypip.in/version/colorama/badge.svg :target: https://pypi.python.org/pypi/colorama/ :alt: Latest Version .. image:: https://travis-ci.org/tartley/colorama.svg?branch=master :target: https://travis-ci.org/tartley/colorama :alt: Build Status Download and docs: http://pypi.python.org/pypi/colorama Source code & Development: https://github.com/tartley/colorama Description =========== Makes ANSI escape character sequences (for producing colored terminal text and cursor positioning) work under MS Windows. ANSI escape character sequences have long been used to produce colored terminal text and cursor positioning on Unix and Macs. Colorama makes this work on Windows, too, by wrapping ``stdout``, stripping ANSI sequences it finds (which would appear as gobbledygook in the output), and converting them into the appropriate win32 calls to modify the state of the terminal. On other platforms, Colorama does nothing. Colorama also provides some shortcuts to help generate ANSI sequences but works fine in conjunction with any other ANSI sequence generation library, such as the venerable Termcolor (http://pypi.python.org/pypi/termcolor) or the fabulous Blessings (https://pypi.python.org/pypi/blessings). This has the upshot of providing a simple cross-platform API for printing colored terminal text from Python, and has the happy side-effect that existing applications or libraries which use ANSI sequences to produce colored output on Linux or Macs can now also work on Windows, simply by calling ``colorama.init()``. An alternative approach is to install ``ansi.sys`` on Windows machines, which provides the same behaviour for all applications running in terminals. Colorama is intended for situations where that isn't easy (e.g., maybe your app doesn't have an installer.) Demo scripts in the source code repository print some colored text using ANSI sequences. Compare their output under Gnome-terminal's built in ANSI handling, versus on Windows Command-Prompt using Colorama: .. image:: https://github.com/tartley/colorama/raw/master/screenshots/ubuntu-demo.png :width: 661 :height: 357 :alt: ANSI sequences on Ubuntu under gnome-terminal. .. image:: https://github.com/tartley/colorama/raw/master/screenshots/windows-demo.png :width: 668 :height: 325 :alt: Same ANSI sequences on Windows, using Colorama. These screengrabs show that, on Windows, Colorama does not support ANSI 'dim text'; it looks the same as 'normal text'. License ======= Copyright Jonathan Hartley 2013. BSD 3-Clause license; see LICENSE file. Dependencies ============ None, other than Python. Tested on Python 2.5.5, 2.6.5, 2.7, 3.1.2, 3.2, 3.3, 3.4 and 3.5. Usage ===== Initialisation -------------- Applications should initialise Colorama using: .. code-block:: python from colorama import init init() On Windows, calling ``init()`` will filter ANSI escape sequences out of any text sent to ``stdout`` or ``stderr``, and replace them with equivalent Win32 calls. On other platforms, calling ``init()`` has no effect (unless you request other optional functionality; see "Init Keyword Args", below). By design, this permits applications to call ``init()`` unconditionally on all platforms, after which ANSI output should just work. To stop using colorama before your program exits, simply call ``deinit()``. This will restore ``stdout`` and ``stderr`` to their original values, so that Colorama is disabled. To resume using Colorama again, call ``reinit()``; it is cheaper to calling ``init()`` again (but does the same thing). Colored Output -------------- Cross-platform printing of colored text can then be done using Colorama's constant shorthand for ANSI escape sequences: .. code-block:: python from colorama import Fore, Back, Style print(Fore.RED + 'some red text') print(Back.GREEN + 'and with a green background') print(Style.DIM + 'and in dim text') print(Style.RESET_ALL) print('back to normal now') ...or simply by manually printing ANSI sequences from your own code: .. code-block:: python print('\033[31m' + 'some red text') print('\033[30m') # and reset to default color ...or, Colorama can be used happily in conjunction with existing ANSI libraries such as Termcolor: .. code-block:: python from colorama import init from termcolor import colored # use Colorama to make Termcolor work on Windows too init() # then use Termcolor for all colored text output print(colored('Hello, World!', 'green', 'on_red')) Available formatting constants are:: Fore: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET. Back: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET. Style: DIM, NORMAL, BRIGHT, RESET_ALL ``Style.RESET_ALL`` resets foreground, background, and brightness. Colorama will perform this reset automatically on program exit. Cursor Positioning ------------------ ANSI codes to reposition the cursor are supported. See ``demos/demo06.py`` for an example of how to generate them. Init Keyword Args ----------------- ``init()`` accepts some ``**kwargs`` to override default behaviour. init(autoreset=False): If you find yourself repeatedly sending reset sequences to turn off color changes at the end of every print, then ``init(autoreset=True)`` will automate that: .. code-block:: python from colorama import init init(autoreset=True) print(Fore.RED + 'some red text') print('automatically back to default color again') init(strip=None): Pass ``True`` or ``False`` to override whether ansi codes should be stripped from the output. The default behaviour is to strip if on Windows or if output is redirected (not a tty). init(convert=None): Pass ``True`` or ``False`` to override whether to convert ANSI codes in the output into win32 calls. The default behaviour is to convert if on Windows and output is to a tty (terminal). init(wrap=True): On Windows, colorama works by replacing ``sys.stdout`` and ``sys.stderr`` with proxy objects, which override the ``.write()`` method to do their work. If this wrapping causes you problems, then this can be disabled by passing ``init(wrap=False)``. The default behaviour is to wrap if ``autoreset`` or ``strip`` or ``convert`` are True. When wrapping is disabled, colored printing on non-Windows platforms will continue to work as normal. To do cross-platform colored output, you can use Colorama's ``AnsiToWin32`` proxy directly: .. code-block:: python import sys from colorama import init, AnsiToWin32 init(wrap=False) stream = AnsiToWin32(sys.stderr).stream # Python 2 print >>stream, Fore.BLUE + 'blue text on stderr' # Python 3 print(Fore.BLUE + 'blue text on stderr', file=stream) Status & Known Problems ======================= I've personally only tested it on Windows XP (CMD, Console2), Ubuntu (gnome-terminal, xterm), and OS X. Some presumably valid ANSI sequences aren't recognised (see details below), but to my knowledge nobody has yet complained about this. Puzzling. See outstanding issues and wishlist: https://github.com/tartley/colorama/issues If anything doesn't work for you, or doesn't do what you expected or hoped for, I'd love to hear about it on that issues list, would be delighted by patches, and would be happy to grant commit access to anyone who submits a working patch or two. Recognised ANSI Sequences ========================= ANSI sequences generally take the form: ESC [ ; ... Where ```` is an integer, and ```` is a single letter. Zero or more params are passed to a ````. If no params are passed, it is generally synonymous with passing a single zero. No spaces exist in the sequence; they have been inserted here simply to read more easily. The only ANSI sequences that colorama converts into win32 calls are:: ESC [ 0 m # reset all (colors and brightness) ESC [ 1 m # bright ESC [ 2 m # dim (looks same as normal brightness) ESC [ 22 m # normal brightness # FOREGROUND: ESC [ 30 m # black ESC [ 31 m # red ESC [ 32 m # green ESC [ 33 m # yellow ESC [ 34 m # blue ESC [ 35 m # magenta ESC [ 36 m # cyan ESC [ 37 m # white ESC [ 39 m # reset # BACKGROUND ESC [ 40 m # black ESC [ 41 m # red ESC [ 42 m # green ESC [ 43 m # yellow ESC [ 44 m # blue ESC [ 45 m # magenta ESC [ 46 m # cyan ESC [ 47 m # white ESC [ 49 m # reset # cursor positioning ESC [ y;x H # position cursor at x across, y down ESC [ y;x f # position cursor at x across, y down ESC [ n A # move cursor n lines up ESC [ n B # move cursor n lines down ESC [ n C # move cursor n characters forward ESC [ n D # move cursor n characters backward # clear the screen ESC [ mode J # clear the screen # clear the line ESC [ mode K # clear the line Multiple numeric params to the ``'m'`` command can be combined into a single sequence:: ESC [ 36 ; 45 ; 1 m # bright cyan text on magenta background All other ANSI sequences of the form ``ESC [ ; ... `` are silently stripped from the output on Windows. Any other form of ANSI sequence, such as single-character codes or alternative initial characters, are not recognised or stripped. It would be cool to add them though. Let me know if it would be useful for you, via the Issues on GitHub. Development =========== Help and fixes welcome! Running tests requires: - Michael Foord's ``mock`` module to be installed. - Tests are written using 2010-era updates to ``unittest``, and require Python 2.7 or greater, OR to have Michael Foord's ``unittest2`` module installed. To run tests:: python -m unittest discover -p *_test.py This, like a few other handy commands, is captured in a ``Makefile``. If you use nose to run the tests, you must pass the ``-s`` flag; otherwise, ``nosetests`` applies its own proxy to ``stdout``, which confuses the unit tests. Thanks ====== * Marc Schlaich (schlamar) for a ``setup.py`` fix for Python2.5. * Marc Abramowitz, reported & fixed a crash on exit with closed ``stdout``, providing a solution to issue #7's setuptools/distutils debate, and other fixes. * User 'eryksun', for guidance on correctly instantiating ``ctypes.windll``. * Matthew McCormick for politely pointing out a longstanding crash on non-Win. * Ben Hoyt, for a magnificent fix under 64-bit Windows. * Jesse at Empty Square for submitting a fix for examples in the README. * User 'jamessp', an observant documentation fix for cursor positioning. * User 'vaal1239', Dave Mckee & Lackner Kristof for a tiny but much-needed Win7 fix. * Julien Stuyck, for wisely suggesting Python3 compatible updates to README. * Daniel Griffith for multiple fabulous patches. * Oscar Lesta for a valuable fix to stop ANSI chars being sent to non-tty output. * Roger Binns, for many suggestions, valuable feedback, & bug reports. * Tim Golden for thought and much appreciated feedback on the initial idea. * User 'Zearin' for updates to the README file. * John Szakmeister for adding support for light colors * Charles Merriam for adding documentation to demos * Jurko for a fix on 64-bit Windows CPython2.5 w/o ctypes * Florian Bruhin for a fix when stdout or stderr are None * Thomas Weininger for fixing ValueError on Windows * Remi Rampin for better Github integration and fixes to the README file * Simeon Visser for closing a file handle using 'with' and updating classifiers to include Python 3.3 and 3.4 * Andy Neff for fixing RESET of LIGHT_EX colors. * Jonathan Hartley for the initial idea and implementation. Keywords: color colour terminal text ansi windows crossplatform xplatform Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Console Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: BSD License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.5 Classifier: Programming Language :: Python :: 2.6 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.1 Classifier: Programming Language :: Python :: 3.2 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Topic :: Terminals colorama-0.3.7/colorama.egg-info/SOURCES.txt0000644000076600000240000000075412667514340021141 0ustar arnonystaff00000000000000CHANGELOG.rst LICENSE.txt MANIFEST.in README.rst setup.cfg setup.py colorama/__init__.py colorama/ansi.py colorama/ansitowin32.py colorama/initialise.py colorama/win32.py colorama/winterm.py colorama.egg-info/PKG-INFO colorama.egg-info/SOURCES.txt colorama.egg-info/dependency_links.txt colorama.egg-info/top_level.txt demos/demo.bat demos/demo.sh demos/demo01.py demos/demo02.py demos/demo03.py demos/demo04.py demos/demo05.py demos/demo06.py demos/demo07.py demos/demo08.py demos/fixpath.pycolorama-0.3.7/colorama.egg-info/dependency_links.txt0000644000076600000240000000000112667514340023315 0ustar arnonystaff00000000000000 colorama-0.3.7/colorama.egg-info/top_level.txt0000644000076600000240000000001112667514340021771 0ustar arnonystaff00000000000000colorama colorama-0.3.7/demos/0000755000076600000240000000000012667514340015067 5ustar arnonystaff00000000000000colorama-0.3.7/demos/demo.bat0000644000076600000240000000205712510742254016501 0ustar arnonystaff00000000000000:: Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. :: Script to demonstrate features of colorama. :: This demo is also used to verify correctness visually, because we don't :: have automated tests. :: Implemented as a bash script which invokes python so that we can test the :: behaviour on exit, which resets default colors again. :: print grid of all colors and brightnesses python demo01.py :: Simple demo of changing foreground, background and brightness. python demo02.py :: Demonstrate the different behavior when autoreset is True and False. python demo03.py :: check that stripped ANSI in redirected stderr does not affect stdout if exist demo04.out del demo04.out python demo04.py 2> demo04.out type demo04.out :: Demonstrate the difference between colorama intialized with wrapping on and off. python demo05.py :: # Demonstrate printing colored, random characters at random positions on the screen python demo06.py :: demo07.py not shown :: Demonstrate cursor relative movement: UP, DOWN, FORWARD, and BACK in colorama.CURSOR colorama-0.3.7/demos/demo.sh0000644000076600000240000000220612575520320016340 0ustar arnonystaff00000000000000#!/usr/bin/env bash # Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. # Script to demonstrate features of colorama. # This demo is also used to verify correctness visually, because we don't have # automated tests. # Implemented as a bash script which invokes python so that we can test the # behaviour on exit, which resets default colors again. # print grid of all colors and brightnesses python demo01.py # Simple demo of changing foreground, background and brightness. python demo02.py # Demonstrate the different behavior when autoreset is True and False. python demo03.py # check that stripped ANSI in redirected stderr does not affect stdout rm -f demo04.out python demo04.py 2> demo04.out cat demo04.out # Demonstrate the difference between colorama intialized with wrapping on and off. python demo05.py # Demonstrate printing colored, random characters at random positions on the screen python demo06.py # demo07.py not shown # Demonstrate cursor relative movement: UP, DOWN, FORWARD, and BACK in colorama.CURSOR #Demonstrate the use of a context manager instead of manually using init and deinit python demo08.py colorama-0.3.7/demos/demo01.py0000644000076600000240000000374112470605461016530 0ustar arnonystaff00000000000000#!/usr/bin/python # Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. # print grid of all colors and brightnesses # uses stdout.write to write chars with no newline nor spaces between them # This should run more-or-less identically on Windows and Unix. from __future__ import print_function import sys # Add parent dir to sys path, so the following 'import colorama' always finds # the local source in preference to any installed version of colorama. import fixpath from colorama import init, Fore, Back, Style init() # Fore, Back and Style are convenience classes for the constant ANSI strings that set # the foreground, background and style. The don't have any magic of their own. FORES = [ Fore.BLACK, Fore.RED, Fore.GREEN, Fore.YELLOW, Fore.BLUE, Fore.MAGENTA, Fore.CYAN, Fore.WHITE ] BACKS = [ Back.BLACK, Back.RED, Back.GREEN, Back.YELLOW, Back.BLUE, Back.MAGENTA, Back.CYAN, Back.WHITE ] STYLES = [ Style.DIM, Style.NORMAL, Style.BRIGHT ] NAMES = { Fore.BLACK: 'black', Fore.RED: 'red', Fore.GREEN: 'green', Fore.YELLOW: 'yellow', Fore.BLUE: 'blue', Fore.MAGENTA: 'magenta', Fore.CYAN: 'cyan', Fore.WHITE: 'white' , Fore.RESET: 'reset', Back.BLACK: 'black', Back.RED: 'red', Back.GREEN: 'green', Back.YELLOW: 'yellow', Back.BLUE: 'blue', Back.MAGENTA: 'magenta', Back.CYAN: 'cyan', Back.WHITE: 'white', Back.RESET: 'reset' } # show the color names sys.stdout.write(' ') for foreground in FORES: sys.stdout.write('%s%-7s' % (foreground, NAMES[foreground])) print() # make a row for each background color for background in BACKS: sys.stdout.write('%s%-7s%s %s' % (background, NAMES[background], Back.RESET, background)) # make a column for each foreground color for foreground in FORES: sys.stdout.write(foreground) # show dim, normal bright for brightness in STYLES: sys.stdout.write('%sX ' % brightness) sys.stdout.write(Style.RESET_ALL + ' ' + background) print(Style.RESET_ALL) print() colorama-0.3.7/demos/demo02.py0000644000076600000240000000107712470605461016531 0ustar arnonystaff00000000000000#!/usr/bin/python # Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. # Simple demo of changing foreground, background and brightness. from __future__ import print_function import fixpath from colorama import init, Fore, Back, Style init() print(Fore.GREEN + 'green, ' + Fore.RED + 'red, ' + Fore.RESET + 'normal, ' , end='') print(Back.GREEN + 'green, ' + Back.RED + 'red, ' + Back.RESET + 'normal, ' , end='') print(Style.DIM + 'dim, ' + Style.BRIGHT + 'bright, ' + Style.NORMAL + 'normal' , end=' ') print() colorama-0.3.7/demos/demo03.py0000644000076600000240000000125212470605461016525 0ustar arnonystaff00000000000000#!/usr/bin/python # Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. # Demonstrate the different behavior when autoreset is True and False. from __future__ import print_function import fixpath from colorama import init, Fore, Back, Style init(autoreset=True) print(Fore.CYAN + Back.MAGENTA + Style.BRIGHT + 'Line 1: colored, with autoreset=True') print('Line 2: When auto reset is True, the color settings need to be set with every print.') init(autoreset=False) print(Fore.YELLOW + Back.BLUE + Style.BRIGHT + 'Line 3: colored, with autoreset=False') print('Line 4: When autoreset=False, the prior color settings linger (this is the default behavior).') colorama-0.3.7/demos/demo04.py0000644000076600000240000000073412470605461016532 0ustar arnonystaff00000000000000#!/usr/bin/python # Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. # check that stripped ANSI in redirected stderr does not affect stdout from __future__ import print_function import sys import fixpath from colorama import init, Fore init() print(Fore.GREEN + 'GREEN set on stdout. ', end='') print(Fore.RED + 'RED redirected stderr', file=sys.stderr) print('Further stdout should be GREEN, i.e., the stderr redirection should not affect stdout.') colorama-0.3.7/demos/demo05.py0000644000076600000240000000172612470605461016535 0ustar arnonystaff00000000000000#!/usr/bin/python # Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. # Demonstrate the difference between colorama intialized with wrapping on and off. # The point of the demonstration is to show how the ANSI wrapping on Windows can be disabled. # The unwrapped cases will be interpreted with ANSI on Unix, but not on Windows. from __future__ import print_function import sys import fixpath from colorama import AnsiToWin32, init, Fore init() print('%sWrapped yellow going to stdout, via the default print function.' % Fore.YELLOW) init(wrap=False) print('%sUnwrapped CYAN going to stdout, via the default print function.' % Fore.CYAN) print('%sUnwrapped CYAN, using the file parameter to write via colorama the AnsiToWin32 function.' % Fore.CYAN, file=AnsiToWin32(sys.stdout)) print('%sUnwrapped RED going to stdout, via the default print function.' % Fore.RED) init() print('%sWrapped RED going to stdout, via the default print function.' % Fore.RED) colorama-0.3.7/demos/demo06.py0000644000076600000240000000340412510742254016526 0ustar arnonystaff00000000000000# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. from __future__ import print_function import fixpath import colorama from colorama import Fore, Back, Style from random import randint, choice from string import printable # Demonstrate printing colored, random characters at random positions on the screen # Fore, Back and Style are convenience classes for the constant ANSI strings that set # the foreground, background and style. The don't have any magic of their own. FORES = [ Fore.BLACK, Fore.RED, Fore.GREEN, Fore.YELLOW, Fore.BLUE, Fore.MAGENTA, Fore.CYAN, Fore.WHITE ] BACKS = [ Back.BLACK, Back.RED, Back.GREEN, Back.YELLOW, Back.BLUE, Back.MAGENTA, Back.CYAN, Back.WHITE ] STYLES = [ Style.DIM, Style.NORMAL, Style.BRIGHT ] # This assumes your terminal is 80x24. Ansi minimum coordinate is (1,1). MINY, MAXY = 1, 24 MINX, MAXX = 1, 80 # set of printable ASCII characters, including a space. CHARS = ' ' + printable.strip() PASSES = 1000 def main(): colorama.init() # gratuitous use of lambda. pos = lambda y, x: '\x1b[%d;%dH' % (y, x) # draw a white border. print(Back.WHITE, end='') print('%s%s' % (pos(MINY, MINX), ' '*MAXX), end='') for y in range(MINY, 1+MAXY): print('%s %s ' % (pos(y, MINX), pos(y, MAXX)), end='') print('%s%s' % (pos(MAXY, MINX), ' '*MAXX), end='') # draw some blinky lights for a while. for i in range(PASSES): print('%s%s%s%s%s' % (pos(randint(1+MINY,MAXY-1), randint(1+MINX,MAXX-1)), choice(FORES), choice(BACKS), choice(STYLES), choice(CHARS)), end='') # put cursor to top, left, and set color to white-on-black with normal brightness. print('%s%s%s%s' % (pos(MINY, MINX), Fore.WHITE, Back.BLACK, Style.NORMAL), end='') if __name__ == '__main__': main() colorama-0.3.7/demos/demo07.py0000644000076600000240000000110112575520457016531 0ustar arnonystaff00000000000000from __future__ import print_function import fixpath import colorama # Demonstrate cursor relative movement: UP, DOWN, FORWARD, and BACK in colorama.CURSOR up = colorama.Cursor.UP down = colorama.Cursor.DOWN forward = colorama.Cursor.FORWARD back = colorama.Cursor.BACK def main(): """ expected output: 1a2 aba 3a4 """ colorama.init() print("aaa") print("aaa") print("aaa") print(forward() + up(2) + "b" + up() + back(2) + "1" + forward() + "2" + back(3) + down(2) + "3" + forward() + "4") if __name__ == '__main__': main() colorama-0.3.7/demos/demo08.py0000644000076600000240000000053012575520560016532 0ustar arnonystaff00000000000000from __future__ import print_function import fixpath from colorama import colorama_text, Fore def main(): """automatically reset stdout""" with colorama_text(): print(Fore.GREEN + 'text is green') print(Fore.RESET + 'text is back to normal') print('text is back to stdout') if __name__ == '__main__': main() colorama-0.3.7/demos/fixpath.py0000644000076600000240000000060112470605461017076 0ustar arnonystaff00000000000000# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. # Add demo dir's parent to sys path, so that 'import colorama' always finds # the local source in preference to any installed version of colorama. import sys from os.path import normpath, dirname, join local_colorama_module = normpath(join(dirname(__file__), '..')) sys.path.insert(0, local_colorama_module) colorama-0.3.7/setup.cfg0000644000076600000240000000013012667514340015573 0ustar arnonystaff00000000000000[bdist_wheel] universal = 1 [egg_info] tag_build = tag_date = 0 tag_svn_revision = 0 colorama-0.3.7/setup.py0000644000076600000240000000427012633113445015467 0ustar arnonystaff00000000000000#!/usr/bin/env python # Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. from __future__ import with_statement import os import re try: from setuptools import setup except ImportError: from distutils.core import setup NAME = 'colorama' def get_long_description(filename): readme = os.path.join(os.path.dirname(__file__), filename) with open(readme) as fp: return fp.read() def read_file(path): with open(os.path.join(os.path.dirname(__file__), path)) as fp: return fp.read() def _get_version_match(content): # Search for lines of the form: # __version__ = 'ver' regex = r"^__version__ = ['\"]([^'\"]*)['\"]" version_match = re.search(regex, content, re.M) if version_match: return version_match.group(1) raise RuntimeError("Unable to find version string.") def get_version(path): return _get_version_match(read_file(path)) setup( name=NAME, version=get_version(os.path.join('colorama', '__init__.py')), description='Cross-platform colored terminal text.', long_description=read_file('README.rst'), keywords='color colour terminal text ansi windows crossplatform xplatform', author='Jonathan Hartley', author_email='tartley@tartley.com', maintainer='Arnon Yaari', url='https://github.com/tartley/colorama', license='BSD', packages=[NAME], # see classifiers http://pypi.python.org/pypi?%3Aaction=list_classifiers classifiers=[ 'Development Status :: 5 - Production/Stable', 'Environment :: Console', 'Intended Audience :: Developers', 'License :: OSI Approved :: BSD License', 'Operating System :: OS Independent', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.5', 'Programming Language :: Python :: 2.6', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.1', 'Programming Language :: Python :: 3.2', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Topic :: Terminals', ] )