v2.3.0

reStructuredText is a mess

.editorconfig

@@ -0,0 +1,17 @@
+# https://editorconfig.org
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.yml]
+indent_size = 2
+
+[Makefile]
+indent_style = tab
+indent_size = 8

.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: jakubroztocil # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom:

.github/workflows/build.yml

@@ -0,0 +1,37 @@
+name: Build
+on: [push, pull_request]
+jobs:
+  extras:
+    # Run coverage and extra tests only once
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions/setup-python@v1
+        with:
+          python-version: 3.8
+      - run: python -m pip install --upgrade pip setuptools wheel
+      - run: make install
+      - run: make pycodestyle
+      - run: make test-cover
+      - run: make codecov-upload
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_REPO_TOKEN }}
+      - run: make test-dist
+  test:
+    # Run core HTTPie tests everywhere
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macOS-latest, windows-latest]
+        python-version: [3.6, 3.7, 3.8]
+        exclude:
+          - os: windows-latest
+            python-version: 3.8
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions/setup-python@v1
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: python -m pip install --upgrade pip setuptools wheel
+      - run: python -m pip install --upgrade --editable .
+      - run: python setup.py test

.gitignore

@@ -1,10 +1,141 @@
-dist
-httpie.egg-info
-build
-*.pyc
-.tox
-README.html
-.coverage
-htmlcov
-.idea
 .DS_Store
+.idea/
+*.egg-info
+.cache/
+*.pyc
+htmlcov
+
+
+##############################################################################
+# The below is GitHub template for Python project. gitignore.
+# <https://github.com/github/gitignore/blob/master/Python.gitignore>
+##############################################################################
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

.travis.yml

@@ -1,9 +0,0 @@
-language: python
-python:
-  - 2.6
-  - 2.7
-  - pypy
-  - 3.3
-script: python setup.py test
-install:
-  - pip install . --use-mirrors

AUTHORS.rst

@@ -2,12 +2,14 @@
 HTTPie authors
 ==============
 
-* `Jakub Roztocil <https://github.com/jkbr>`_
+* `Jakub Roztocil <https://github.com/jakubroztocil>`_
 
 
 Patches and ideas
 -----------------
 
+`Complete list of contributors on GitHub <https://github.com/jakubroztocil/httpie/graphs/contributors>`_
+
 * `Cláudia T. Delgado <https://github.com/claudiatd>`_ (logo)
 * `Hank Gay <https://github.com/gthank>`_
 * `Jake Basile <https://github.com/jakebasile>`_
@@ -28,3 +30,13 @@ Patches and ideas
 * `Tomek Wójcik <https://github.com/tomekwojcik>`_
 * `Davey Shafik <https://github.com/dshafik>`_
 * `cido <https://github.com/cido>`_
+* `Justin Bonnar <https://github.com/jargonjustin>`_
+* `Nathan LaFreniere <https://github.com/nlf>`_
+* `Matthias Lehmann <https://github.com/matleh>`_
+* `Dennis Brakhane <https://github.com/brakhane>`_
+* `Matt Layman <https://github.com/mblayman>`_
+* `Edward Yang <https://github.com/honorabrutroll>`_
+* `Aleksandr Vinokurov <https://github.com/aleksandr-vin>`_
+* `Jeff Byrnes <https://github.com/jeffbyrnes>`_
+
+

CHANGELOG.rst

@@ -0,0 +1,475 @@
+==========
+Change Log
+==========
+
+This document records all notable changes to `HTTPie <https://httpie.org>`_.
+This project adheres to `Semantic Versioning <https://semver.org/>`_.
+
+
+`2.3.0`_ (2020-10-25)
+-------------------------
+
+* Added support for multipart upload streaming (`#684`_).
+* Added support for body-from-file upload streaming (``http httpbin.org/post @file``).
+* Added ``--chunked`` to allow chunked transfer encoding.
+* Added ``--multipart`` to allow ``multipart/form-data`` encoding for non-file ``--form`` requests as well.
+* Added ``--boundary`` to allow a custom boundary string for ``multipart/form-data`` requests.
+* Added support for combining cookies specified on the CLI and in a session file (`#932`_).
+* Added out of the box SOCKS support with no extra installation (`#904`_).
+* Added ``--quiet, -q`` flag to enforce silent behaviour.
+* Fixed the handling of invalid ``expires`` dates in ``Set-Cookie`` headers (`#963`_).
+* Removed Tox testing entirely (`#943`_).
+
+
+`2.2.0`_ (2020-06-18)
+-------------------------
+
+* Added support for custom content types for uploaded files (`#668`_).
+* Added support for ``$XDG_CONFIG_HOME`` (`#920`_).
+* Added support for ``Set-Cookie``-triggered cookie expiration (`#853`_).
+* Added ``--format-options`` to allow disabling sorting, etc. (`#128`_)
+* Added ``--sorted`` and ``--unsorted`` shortcuts for (un)setting all sorting-related ``--format-options``. (`#128`_)
+* Added ``--ciphers`` to allow configuring OpenSSL ciphers (`#870`_).
+* Added ``netrc`` support for auth plugins. Enabled for ``--auth-type=basic``
+  and ``digest``, 3rd parties may opt in (`#718`_, `#719`_, `#852`_, `#934`_).
+* Fixed built-in plugins-related circular imports (`#925`_).
+
+
+`2.1.0`_ (2020-04-18)
+---------------------
+
+* Added ``--path-as-is`` to bypass dot segment (``/../`` or ``/./``)
+  URL squashing (`#895`_).
+* Changed the default ``Accept`` header value for JSON requests from
+  ``application/json, */*`` to ``application/json, */*;q=0.5``
+  to clearly indicate preference (`#488`_).
+* Fixed ``--form`` file upload mixed with redirected ``stdin`` error handling
+  (`#840`_).
+
+
+`2.0.0`_ (2020-01-12)
+-------------------------
+* Removed Python 2.7 support (`EOL Jan 2020 <https://www.python.org/doc/sunset-python-2/>`_).
+* Added ``--offline`` to allow building an HTTP request and printing it but not
+  actually sending it over the network.
+* Replaced the old collect-all-then-process handling of HTTP communication
+  with one-by-one processing of each HTTP request or response as they become
+  available. This means that you can see headers immediately,
+  see what is being sent even if the request fails, etc.
+* Removed automatic config file creation to avoid concurrency issues.
+* Removed the default 30-second connection ``--timeout`` limit.
+* Removed Python’s default limit of 100 response headers.
+* Added ``--max-headers`` to allow setting the max header limit.
+* Added ``--compress`` to allow request body compression.
+* Added ``--ignore-netrc`` to allow bypassing credentials from ``.netrc``.
+* Added ``https`` alias command with ``https://`` as the default scheme.
+* Added ``$ALL_PROXY`` documentation.
+* Added type annotations throughout the codebase.
+* Added ``tests/`` to the PyPi package for the convenience of
+  downstream package maintainers.
+* Fixed an error when ``stdin`` was a closed fd.
+* Improved ``--debug`` output formatting.
+
+
+`1.0.3`_ (2019-08-26)
+---------------------
+
+* Fixed CVE-2019-10751 — the way the output filename is generated for
+  ``--download`` requests without ``--output`` resulting in a redirect has
+  been changed to only consider the initial URL as the base for the generated
+  filename, and not the final one. This fixes a potential security issue under
+  the following scenario:
+
+  1. A ``--download`` request with no explicit ``--output`` is made (e.g.,
+     ``$ http -d example.org/file.txt``), instructing httpie to
+     `generate the output filename <https://httpie.org/doc#downloaded-filename>`_
+     from the ``Content-Disposition`` response header, or from the URL if the header
+     is not provided.
+  2. The server handling the request has been modified by an attacker and
+     instead of the expected response the URL returns a redirect to another
+     URL, e.g., ``attacker.example.org/.bash_profile``, whose response does
+     not provide  a ``Content-Disposition`` header (i.e., the base for the
+     generated filename becomes ``.bash_profile`` instead of ``file.txt``).
+  3. Your current directory doesn’t already contain ``.bash_profile``
+     (i.e., no unique suffix is added to the generated filename).
+  4. You don’t notice the potentially unexpected output filename
+     as reported by httpie in the console output
+     (e.g., ``Downloading 100.00 B to ".bash_profile"``).
+
+  Reported by Raul Onitza and Giulio Comi.
+
+
+`1.0.2`_ (2018-11-14)
+-------------------------
+
+* Fixed tests for installation with pyOpenSSL.
+
+
+`1.0.1`_ (2018-11-14)
+-------------------------
+
+* Removed external URL calls from tests.
+
+
+`1.0.0`_ (2018-11-02)
+-------------------------
+
+* Added ``--style=auto`` which follows the terminal ANSI color styles.
+* Added support for selecting TLS 1.3 via ``--ssl=tls1.3``
+  (available once implemented in upstream libraries).
+* Added ``true``/``false`` as valid values for ``--verify``
+  (in addition to ``yes``/``no``) and the boolean value is case-insensitive.
+* Changed the default ``--style`` from ``solarized`` to ``auto`` (on Windows it stays ``fruity``).
+* Fixed default headers being incorrectly case-sensitive.
+* Removed Python 2.6 support.
+
+
+
+`0.9.9`_ (2016-12-08)
+---------------------
+
+* Fixed README.
+
+
+`0.9.8`_ (2016-12-08)
+---------------------
+
+* Extended auth plugin API.
+* Added exit status code ``7`` for plugin errors.
+* Added support for ``curses``-less Python installations.
+* Fixed ``REQUEST_ITEM`` arg incorrectly being reported as required.
+* Improved ``CTRL-C`` interrupt handling.
+* Added the standard exit status code ``130`` for keyboard interrupts.
+
+
+`0.9.6`_ (2016-08-13)
+---------------------
+
+* Added Python 3 as a dependency for Homebrew installations
+  to ensure some of the newer HTTP features work out of the box
+  for macOS users (starting with HTTPie 0.9.4.).
+* Added the ability to unset a request header with ``Header:``, and send an
+  empty value with ``Header;``.
+* Added ``--default-scheme <URL_SCHEME>`` to enable things like
+  ``$ alias https='http --default-scheme=https``.
+* Added ``-I`` as a shortcut for ``--ignore-stdin``.
+* Added fish shell completion (located in ``extras/httpie-completion.fish``
+  in the GitHub repo).
+* Updated ``requests`` to 2.10.0 so that SOCKS support can be added via
+  ``pip install requests[socks]``.
+* Changed the default JSON ``Accept`` header from ``application/json``
+  to ``application/json, */*``.
+* Changed the pre-processing of request HTTP headers so that any leading
+  and trailing whitespace is removed.
+
+
+`0.9.4`_ (2016-07-01)
+---------------------
+
+* Added ``Content-Type`` of files uploaded in ``multipart/form-data`` requests
+* Added ``--ssl=<PROTOCOL>`` to specify the desired SSL/TLS protocol version
+  to use for HTTPS requests.
+* Added JSON detection with ``--json, -j`` to work around incorrect
+  ``Content-Type``
+* Added ``--all`` to show intermediate responses such as redirects (with ``--follow``)
+* Added ``--history-print, -P WHAT`` to specify formatting of intermediate responses
+* Added ``--max-redirects=N`` (default 30)
+* Added ``-A`` as short name for ``--auth-type``
+* Added ``-F`` as short name for ``--follow``
+* Removed the ``implicit_content_type`` config option
+  (use ``"default_options": ["--form"]`` instead)
+* Redirected ``stdout`` doesn't trigger an error anymore when ``--output FILE``
+  is set
+* Changed the default ``--style`` back to ``solarized`` for better support
+  of light and dark terminals
+* Improved ``--debug`` output
+* Fixed ``--session`` when used with ``--download``
+* Fixed ``--download`` to trim too long filenames before saving the file
+* Fixed the handling of ``Content-Type`` with multiple ``+subtype`` parts
+* Removed the XML formatter as the implementation suffered from multiple issues
+
+
+
+`0.9.3`_ (2016-01-01)
+---------------------
+
+* Changed the default color ``--style`` from ``solarized`` to ``monokai``
+* Added basic Bash autocomplete support (need to be installed manually)
+* Added request details to connection error messages
+* Fixed ``'requests.packages.urllib3' has no attribute 'disable_warnings'``
+  errors that occurred in some installations
+* Fixed colors and formatting on Windows
+* Fixed ``--auth`` prompt on Windows
+
+
+`0.9.2`_ (2015-02-24)
+---------------------
+
+* Fixed compatibility with Requests 2.5.1
+* Changed the default JSON ``Content-Type`` to ``application/json`` as UTF-8
+  is the default JSON encoding
+
+
+`0.9.1`_ (2015-02-07)
+---------------------
+
+* Added support for Requests transport adapter plugins
+  (see `httpie-unixsocket <https://github.com/httpie/httpie-unixsocket>`_
+  and `httpie-http2 <https://github.com/httpie/httpie-http2>`_)
+
+
+`0.9.0`_ (2015-01-31)
+---------------------
+
+* Added ``--cert`` and ``--cert-key`` parameters to specify a client side
+  certificate and private key for SSL
+* Improved unicode support
+* Improved terminal color depth detection via ``curses``
+* To make it easier to deal with Windows paths in request items, ``\``
+  now only escapes special characters (the ones that are used as key-value
+  separators by HTTPie)
+* Switched from ``unittest`` to ``pytest``
+* Added Python `wheel` support
+* Various test suite improvements
+* Added ``CONTRIBUTING``
+* Fixed ``User-Agent`` overwriting when used within a session
+* Fixed handling of empty passwords in URL credentials
+* Fixed multiple file uploads with the same form field name
+* Fixed ``--output=/dev/null`` on Linux
+* Miscellaneous bugfixes
+
+
+`0.8.0`_ (2014-01-25)
+---------------------
+
+* Added ``field=@file.txt`` and ``field:=@file.json`` for embedding
+  the contents of text and JSON files into request data
+* Added curl-style shorthand for localhost
+* Fixed request ``Host`` header value output so that it doesn't contain
+  credentials, if included in the URL
+
+
+`0.7.1`_ (2013-09-24)
+---------------------
+
+* Added ``--ignore-stdin``
+* Added support for auth plugins
+* Improved ``--help`` output
+* Improved ``Content-Disposition`` parsing for ``--download`` mode
+* Update to Requests 2.0.0
+
+
+`0.6.0`_ (2013-06-03)
+---------------------
+
+* XML data is now formatted
+* ``--session`` and ``--session-read-only`` now also accept paths to
+  session files (eg. ``http --session=/tmp/session.json example.org``)
+
+
+`0.5.1`_ (2013-05-13)
+---------------------
+
+* ``Content-*`` and ``If-*`` request headers are not stored in sessions
+  anymore as they are request-specific
+
+
+`0.5.0`_ (2013-04-27)
+---------------------
+
+* Added a download mode via ``--download``
+* Fixes miscellaneous bugs
+
+
+`0.4.1`_ (2013-02-26)
+---------------------
+
+* Fixed ``setup.py``
+
+
+`0.4.0`_ (2013-02-22)
+---------------------
+
+* Added Python 3.3 compatibility
+* Added Requests >= v1.0.4 compatibility
+* Added support for credentials in URL
+* Added ``--no-option`` for every ``--option`` to be config-friendly
+* Mutually exclusive arguments can be specified multiple times. The
+  last value is used
+
+
+`0.3.0`_ (2012-09-21)
+---------------------
+
+* Allow output redirection on Windows
+* Added configuration file
+* Added persistent session support
+* Renamed ``--allow-redirects`` to ``--follow``
+* Improved the usability of ``http --help``
+* Fixed installation on Windows with Python 3
+* Fixed colorized output on Windows with Python 3
+* CRLF HTTP header field separation in the output
+* Added exit status code ``2`` for timed-out requests
+* Added the option to separate colorizing and formatting
+  (``--pretty=all``, ``--pretty=colors`` and ``--pretty=format``)
+  ``--ugly`` has bee removed in favor of ``--pretty=none``
+
+
+`0.2.7`_ (2012-08-07)
+---------------------
+
+* Added compatibility with Requests 0.13.6
+* Added streamed terminal output. ``--stream, -S`` can be used to enable
+  streaming also with ``--pretty`` and to ensure a more frequent output
+  flushing
+* Added support for efficient large file downloads
+* Sort headers by name (unless ``--pretty=none``)
+* Response body is fetched only when needed (e.g., not with ``--headers``)
+* Improved content type matching
+* Updated Solarized color scheme
+* Windows: Added ``--output FILE`` to store output into a file
+  (piping results in corrupted data on Windows)
+* Proper handling of binary requests and responses
+* Fixed printing of ``multipart/form-data`` requests
+* Renamed ``--traceback`` to ``--debug``
+
+
+`0.2.6`_ (2012-07-26)
+---------------------
+
+* The short option for ``--headers`` is now ``-h`` (``-t`` has been
+  removed, for usage use ``--help``)
+* Form data and URL parameters can have multiple fields with the same name
+  (e.g.,``http -f url a=1 a=2``)
+* Added ``--check-status`` to exit with an error on HTTP 3xx, 4xx and
+  5xx (3, 4, and 5, respectively)
+* If the output is piped to another program or redirected to a file,
+  the default behaviour is to only print the response body
+  (It can still be overwritten via the ``--print`` flag.)
+* Improved highlighting of HTTP headers
+* Added query string parameters (``param==value``)
+* Added support for terminal colors under Windows
+
+
+`0.2.5`_ (2012-07-17)
+---------------------
+
+* Unicode characters in prettified JSON now don't get escaped for
+  improved readability
+* --auth now prompts for a password if only a username provided
+* Added support for request payloads from a file path with automatic
+  ``Content-Type`` (``http URL @/path``)
+* Fixed missing query string when displaying the request headers via
+  ``--verbose``
+* Fixed Content-Type for requests with no data
+
+
+`0.2.2`_ (2012-06-24)
+---------------------
+
+* The ``METHOD`` positional argument can now be omitted (defaults to
+  ``GET``, or to ``POST`` with data)
+* Fixed --verbose --form
+* Added support for Tox
+
+
+`0.2.1`_ (2012-06-13)
+---------------------
+
+* Added compatibility with ``requests-0.12.1``
+* Dropped custom JSON and HTTP lexers in favor of the ones newly included
+  in ``pygments-1.5``
+
+
+`0.2.0`_ (2012-04-25)
+---------------------
+
+* Added Python 3 support
+* Added the ability to print the HTTP request as well as the response
+  (see ``--print`` and ``--verbose``)
+* Added support for Digest authentication
+* Added file upload support
+  (``http -f POST file_field_name@/path/to/file``)
+* Improved syntax highlighting for JSON
+* Added support for field name escaping
+* Many bug fixes
+
+
+`0.1.6`_ (2012-03-04)
+---------------------
+
+* Fixed ``setup.py``
+
+
+`0.1.5`_ (2012-03-04)
+---------------------
+
+* Many improvements and bug fixes
+
+
+`0.1.4`_ (2012-02-28)
+---------------------
+
+* Many improvements and bug fixes
+
+
+`0.1.0`_ (2012-02-25)
+---------------------
+
+* Initial public release
+
+
+.. _`0.1.0`: https://github.com/jakubroztocil/httpie/commit/b966efa
+.. _0.1.4: https://github.com/jakubroztocil/httpie/compare/b966efa...0.1.4
+.. _0.1.5: https://github.com/jakubroztocil/httpie/compare/0.1.4...0.1.5
+.. _0.1.6: https://github.com/jakubroztocil/httpie/compare/0.1.5...0.1.6
+.. _0.2.0: https://github.com/jakubroztocil/httpie/compare/0.1.6...0.2.0
+.. _0.2.1: https://github.com/jakubroztocil/httpie/compare/0.2.0...0.2.1
+.. _0.2.2: https://github.com/jakubroztocil/httpie/compare/0.2.1...0.2.2
+.. _0.2.5: https://github.com/jakubroztocil/httpie/compare/0.2.2...0.2.5
+.. _0.2.6: https://github.com/jakubroztocil/httpie/compare/0.2.5...0.2.6
+.. _0.2.7: https://github.com/jakubroztocil/httpie/compare/0.2.5...0.2.7
+.. _0.3.0: https://github.com/jakubroztocil/httpie/compare/0.2.7...0.3.0
+.. _0.4.0: https://github.com/jakubroztocil/httpie/compare/0.3.0...0.4.0
+.. _0.4.1: https://github.com/jakubroztocil/httpie/compare/0.4.0...0.4.1
+.. _0.5.0: https://github.com/jakubroztocil/httpie/compare/0.4.1...0.5.0
+.. _0.5.1: https://github.com/jakubroztocil/httpie/compare/0.5.0...0.5.1
+.. _0.6.0: https://github.com/jakubroztocil/httpie/compare/0.5.1...0.6.0
+.. _0.7.1: https://github.com/jakubroztocil/httpie/compare/0.6.0...0.7.1
+.. _0.8.0: https://github.com/jakubroztocil/httpie/compare/0.7.1...0.8.0
+.. _0.9.0: https://github.com/jakubroztocil/httpie/compare/0.8.0...0.9.0
+.. _0.9.1: https://github.com/jakubroztocil/httpie/compare/0.9.0...0.9.1
+.. _0.9.2: https://github.com/jakubroztocil/httpie/compare/0.9.1...0.9.2
+.. _0.9.3: https://github.com/jakubroztocil/httpie/compare/0.9.2...0.9.3
+.. _0.9.4: https://github.com/jakubroztocil/httpie/compare/0.9.3...0.9.4
+.. _0.9.6: https://github.com/jakubroztocil/httpie/compare/0.9.4...0.9.6
+.. _0.9.8: https://github.com/jakubroztocil/httpie/compare/0.9.6...0.9.8
+.. _0.9.9: https://github.com/jakubroztocil/httpie/compare/0.9.8...0.9.9
+.. _1.0.0: https://github.com/jakubroztocil/httpie/compare/0.9.9...1.0.0
+.. _1.0.1: https://github.com/jakubroztocil/httpie/compare/1.0.0...1.0.1
+.. _1.0.2: https://github.com/jakubroztocil/httpie/compare/1.0.1...1.0.2
+.. _1.0.3: https://github.com/jakubroztocil/httpie/compare/1.0.2...1.0.3
+.. _2.0.0: https://github.com/jakubroztocil/httpie/compare/1.0.3...2.0.0
+.. _2.1.0: https://github.com/jakubroztocil/httpie/compare/2.0.0...2.1.0
+.. _2.2.0: https://github.com/jakubroztocil/httpie/compare/2.1.0...2.2.0
+.. _2.3.0: https://github.com/jakubroztocil/httpie/compare/2.2.0...2.3.0
+
+
+.. _#128: https://github.com/jakubroztocil/httpie/issues/128
+.. _#488: https://github.com/jakubroztocil/httpie/issues/488
+.. _#668: https://github.com/jakubroztocil/httpie/issues/668
+.. _#684: https://github.com/jakubroztocil/httpie/issues/684
+.. _#718: https://github.com/jakubroztocil/httpie/issues/718
+.. _#719: https://github.com/jakubroztocil/httpie/issues/719
+.. _#840: https://github.com/jakubroztocil/httpie/issues/840
+.. _#853: https://github.com/jakubroztocil/httpie/issues/853
+.. _#852: https://github.com/jakubroztocil/httpie/issues/852
+.. _#870: https://github.com/jakubroztocil/httpie/issues/870
+.. _#895: https://github.com/jakubroztocil/httpie/issues/895
+.. _#920: https://github.com/jakubroztocil/httpie/issues/920
+.. _#904: https://github.com/jakubroztocil/httpie/issues/904
+.. _#925: https://github.com/jakubroztocil/httpie/issues/925
+.. _#932: https://github.com/jakubroztocil/httpie/issues/932
+.. _#934: https://github.com/jakubroztocil/httpie/issues/934
+.. _#943: https://github.com/jakubroztocil/httpie/issues/943
+.. _#963: https://github.com/jakubroztocil/httpie/issues/963

CODE_OF_CONDUCT.md

@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at jakub@roztocil.co. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

CONTRIBUTING.rst

@@ -0,0 +1,239 @@
+######################
+Contributing to HTTPie
+######################
+
+Bug reports and code and documentation patches are welcome. You can
+help this project also by using the development version of HTTPie
+and by reporting any bugs you might encounter.
+
+1. Reporting bugs
+=================
+
+**It's important that you provide the full command argument list
+as well as the output of the failing command.**
+Use the ``--debug`` flag and copy&paste both the command and its output
+to your bug report, e.g.:
+
+.. code-block:: bash
+
+    $ http --debug <COMPLETE ARGUMENT LIST THAT TRIGGERS THE ERROR>
+
+    <COMPLETE OUTPUT>
+
+
+2. Contributing Code and Docs
+=============================
+
+Before working on a new feature or a bug, please browse `existing issues`_
+to see whether it has previously  been discussed.
+
+If your change alters HTTPie’s behaviour or interface, it's a good idea to
+discuss it before you start working on it.
+
+If you are fixing an issue, the first step should be to create a test case that
+reproduces the incorrect behaviour. That will also help you to build an
+understanding of the issue at hand.
+
+**Pull requests introducing code changes without tests
+will generally not get merged. The same goes for PRs changing HTTPie’s
+behaviour and not providing documentation.**
+
+Conversely, PRs consisting of documentation improvements or tests
+for existing-yet-previously-untested behavior will very likely be merged.
+Therefore, docs and tests improvements are a great candidate for your first
+contribution.
+
+Consider also adding a ``CHANGELOG`` entry for your changes.
+
+
+Development Environment
+--------------------------------
+
+
+Getting the code
+****************
+
+Go to https://github.com/jakubroztocil/httpie and fork the project repository.
+
+
+.. code-block:: bash
+
+    # Clone your fork
+    git clone git@github.com:<YOU>/httpie.git
+
+    # Enter the project directory
+    cd httpie
+
+    # Create a branch for your changes
+    git checkout -b my_topical_branch
+
+
+Setup
+*****
+
+The `Makefile`_ contains a bunch of tasks to get you started. Just run
+the following command, which:
+
+
+* Creates an isolated Python virtual environment inside ``./venv``
+  (via the standard library `venv`_ tool);
+* installs all dependencies and also installs HTTPie
+  (in editable mode so that the ``http`` command will point to your
+  working copy).
+* and runs tests (It is the same as running ``make install test``).
+
+
+.. code-block:: bash
+
+    make
+
+
+
+Python virtual environment
+**************************
+
+Activate the Python virtual environment—created via the ``make install``
+task during `setup`_—for your active shell session using the following command:
+
+.. code-block:: bash
+
+    source venv/bin/activate
+
+(If you use ``virtualenvwrapper``, you can also use ``workon httpie`` to
+activate the environment — we have created a symlink for you. It’s a bit of
+a hack but it works™.)
+
+You should now see ``(httpie)`` next to your shell prompt, and
+the ``http`` command should point to your development copy:
+
+.. code-block::
+
+    (httpie) ~/Code/httpie $ which http
+    /Users/jakub/Code/httpie/venv/bin/http
+    (httpie) ~/Code/httpie $ http --version
+    2.0.0-dev
+
+(Btw, you don’t need to activate the virtual environment if you just want
+run some of the ``make`` tasks. You can also invoke the development
+version of HTTPie directly with ``./venv/bin/http`` without having to activate
+the environment first. The same goes for ``./venv/bin/py.test``, etc.).
+
+
+Making Changes
+--------------
+
+Please make sure your changes conform to `Style Guide for Python Code`_ (PEP8)
+and that ``make pycodestyle`` passes.
+
+
+Testing & CI
+------------
+
+Please add tests for any new features and bug fixes.
+
+When you open a pull request,
+`GitHub Actions <https://github.com/jakubroztocil/httpie/actions>`_
+will automatically run HTTPie’s `test suite`_ against your code
+so please make sure all checks pass.
+
+
+Running tests locally
+*********************
+
+HTTPie uses the `pytest`_ runner.
+
+
+.. code-block:: bash
+
+    # Run tests on the current Python interpreter with coverage.
+    make test
+
+    # Run tests with coverage
+    make test-cover
+
+    # Test PEP8 compliance
+    make pycodestyle
+
+    # Run extended tests — for code as well as .rst files syntax, packaging, etc.
+    make test-all
+
+
+Running specific tests
+**********************
+
+After you have activated your virtual environment (see `setup`_), you
+can run specific tests from the terminal:
+
+.. code-block:: bash
+
+    # Run specific tests on the current Python
+    py.test tests/test_uploads.py
+    py.test tests/test_uploads.py::TestMultipartFormDataFileUpload
+    py.test tests/test_uploads.py::TestMultipartFormDataFileUpload::test_upload_ok
+
+-----
+
+See `Makefile`_ for additional development utilities.
+
+Windows
+*******
+
+If you are on a Windows machine and not able to run ``make``,
+follow the next steps for a basic setup. As a prerequisite, you need to have
+Python 3.6+ installed.
+
+Create a virtual environment and activate it:
+
+.. code-block:: powershell
+
+    python -m venv --prompt httpie venv
+    venv\Scripts\activate
+
+Install HTTPie in editable mode with all the dependencies:
+
+.. code-block:: powershell
+
+    pip install --upgrade -e . -r requirements-dev.txt
+
+You should now see ``(httpie)`` next to your shell prompt, and
+the ``http`` command should point to your development copy:
+
+.. code-block:: powershell
+
+    # In PowerShell:
+    (httpie) PS C:\Users\ovezovs\httpie> Get-Command http
+    CommandType     Name                                               Version    Source
+    -----------     ----                                               -------    ------
+    Application     http.exe                                           0.0.0.0    C:\Users\ovezovs\httpie\venv\Scripts\http.exe
+
+.. code-block:: bash
+
+    # In CMD:
+    (httpie) C:\Users\ovezovs\httpie> where http
+    C:\Users\ovezovs\httpie\venv\Scripts\http.exe
+    C:\Users\ovezovs\AppData\Local\Programs\Python\Python38-32\Scripts\http.exe
+
+    (httpie) C:\Users\ovezovs\httpie> http --version
+    2.3.0-dev
+
+Use ``pytest`` to run tests locally with an active virtual environment:
+
+.. code-block:: bash
+
+    # Run all tests
+    py.test
+
+
+-----
+
+
+Finally, feel free to add yourself to `AUTHORS`_!
+
+
+.. _existing issues: https://github.com/jakubroztocil/httpie/issues?state=open
+.. _AUTHORS: https://github.com/jakubroztocil/httpie/blob/master/AUTHORS.rst
+.. _Makefile: https://github.com/jakubroztocil/httpie/blob/master/Makefile
+.. _venv: https://docs.python.org/3/library/venv.html
+.. _pytest: https://pytest.org/
+.. _Style Guide for Python Code: https://python.org/dev/peps/pep-0008/
+.. _test suite: https://github.com/jakubroztocil/httpie/tree/master/tests

LICENSE

@@ -1,4 +1,4 @@
-Copyright © 2012 Jakub Roztocil <jakub@roztocil.name>
+Copyright © 2012-2020 Jakub Roztocil <jakub@roztocil.co>
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
@@ -10,14 +10,14 @@ modification, are permitted provided that the following conditions are met:
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
 
-    3. Neither the name of The author nor the names of its contributors may
-       be used to endorse or promote products derived from this software
+    3. Neither the name of the copyright holder nor the names 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 AUTHOR AND CONTRIBUTORS "AS IS" AND
+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 AUTHOR AND CONTRIBUTORS BE LIABLE FOR
+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

MANIFEST.in

@@ -1 +1,7 @@
-include README.rst LICENSE
+include LICENSE
+include README.rst
+include CHANGELOG.rst
+include AUTHORS.rst
+
+# <https://github.com/jakubroztocil/httpie/issues/182>
+recursive-include tests/ *

Makefile

@@ -0,0 +1,187 @@
+###############################################################################
+# See ./CONTRIBUTING.rst
+###############################################################################
+
+ROOT_DIR:=$(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))
+VERSION=$(shell grep __version__ httpie/__init__.py)
+REQUIREMENTS=requirements-dev.txt
+H1="\n\n\033[0;32m\#\#\# "
+H1END=" \#\#\# \033[0m\n"
+
+
+# Only used to create our venv.
+SYSTEM_PYTHON=python3
+
+VENV_ROOT=venv
+VENV_BIN=$(VENV_ROOT)/bin
+VENV_PIP=$(VENV_BIN)/pip3
+VENV_PYTHON=$(VENV_BIN)/python
+
+
+export PATH := $(VENV_BIN):$(PATH)
+
+
+all: uninstall-httpie install test
+
+
+install: venv
+	@echo $(H1)Installing dev requirements$(H1END)
+	$(VENV_PIP) install --upgrade -r $(REQUIREMENTS)
+
+	@echo $(H1)Installing HTTPie$(H1END)
+	$(VENV_PIP) install --upgrade --editable .
+
+	@echo
+
+clean:
+	@echo $(H1)Cleaning up$(H1END)
+	rm -rf $(VENV_ROOT)
+	# Remove symlink for virtualenvwrapper, if we’ve created one.
+	[ -n "$(WORKON_HOME)" -a -L "$(WORKON_HOME)/httpie" -a -f "$(WORKON_HOME)/httpie" ] && rm $(WORKON_HOME)/httpie || true
+	rm -rf *.egg dist build .coverage .cache .pytest_cache httpie.egg-info
+	find . -name '__pycache__' -delete -o -name '*.pyc' -delete
+	@echo
+
+
+venv:
+	@echo $(H1)Creating a Python environment $(VENV_ROOT) $(H1END)
+
+	$(SYSTEM_PYTHON) -m venv --prompt httpie $(VENV_ROOT)
+
+	@echo
+	@echo done.
+	@echo
+	@echo To active it manually, run:
+	@echo
+	@echo "    source $(VENV_BIN)/activate"
+	@echo
+	@echo '(learn more: https://docs.python.org/3/library/venv.html)'
+	@echo
+	@if [ -n "$(WORKON_HOME)" ]; then \
+		echo $(ROOT_DIR) >  $(VENV_ROOT)/.project; \
+		if [ ! -d $(WORKON_HOME)/httpie -a ! -L $(WORKON_HOME)/httpie ]; then \
+			ln -s $(ROOT_DIR)/$(VENV_ROOT) $(WORKON_HOME)/httpie ; \
+			echo ''; \
+			echo 'Since you use virtualenvwrapper, we created a symlink'; \
+			echo 'so you can also use "workon httpie" to activate the venv.'; \
+			echo ''; \
+		fi; \
+	fi
+
+
+###############################################################################
+# Testing
+###############################################################################
+
+
+test:
+	@echo $(H1)Running tests$(HEADER_EXTRA)$(H1END)
+	$(VENV_BIN)/py.test $(COV) ./httpie $(COV) ./tests --doctest-modules --verbose ./httpie ./tests
+	@echo
+
+
+test-cover: COV=--cov
+test-cover: HEADER_EXTRA=' (with coverage)'
+test-cover: test
+
+
+# test-all is meant to test everything — even this Makefile
+test-all: clean install test test-dist pycodestyle
+	@echo
+
+
+test-dist: test-sdist test-bdist-wheel
+	@echo
+
+
+test-sdist: clean venv
+	@echo $(H1)Testing sdist build an installation$(H1END)
+	$(VENV_PYTHON) setup.py sdist
+	$(VENV_PIP) install --force-reinstall --upgrade dist/*.gz
+	$(VENV_BIN)/http --version
+	@echo
+
+
+test-bdist-wheel: clean venv
+	@echo $(H1)Testing wheel build an installation$(H1END)
+	$(VENV_PIP) install wheel
+	$(VENV_PYTHON) setup.py bdist_wheel
+	$(VENV_PIP) install --force-reinstall --upgrade dist/*.whl
+	$(VENV_BIN)/http --version
+	@echo
+
+
+pycodestyle:
+	@echo $(H1)Running pycodestyle$(H1END)
+	@[ -f $(VENV_BIN)/pycodestyle ] || $(VENV_PIP) install pycodestyle
+	$(VENV_BIN)/pycodestyle httpie/ tests/ extras/ *.py
+	@echo
+
+
+codecov-upload:
+	@echo $(H1)Running codecov$(H1END)
+	@[ -f $(VENV_BIN)/codecov ] || $(VENV_PIP) install codecov
+	# $(VENV_BIN)/codecov --required
+	$(VENV_BIN)/codecov
+	@echo
+
+
+###############################################################################
+# Publishing to PyPi
+###############################################################################
+
+
+publish: test-all publish-no-test
+
+
+publish-no-test:
+	@echo $(H1)Testing wheel build an installation$(H1END)
+	@echo "$(VERSION)"
+	@echo "$(VERSION)" | grep -q "dev" && echo '!!!Not publishing dev version!!!' && exit 1 || echo ok
+	$(VENV_PYTHON) setup.py sdist bdist_wheel
+	$(VENV_BIN)/twine upload dist/*
+	@echo
+
+
+
+###############################################################################
+# Uninstalling
+###############################################################################
+
+uninstall-httpie:
+	@echo $(H1)Uninstalling httpie$(H1END)
+	- $(VENV_PIP) uninstall --yes httpie &2>/dev/null
+
+	@echo "Verifying…"
+	cd .. && ! $(VENV_PYTHON) -m httpie --version &2>/dev/null
+
+	@echo "Done"
+	@echo
+
+
+###############################################################################
+# Docs
+###############################################################################
+
+pdf:
+	@echo "Converting README.rst to PDF…"
+	rst2pdf \
+		--strip-elements-with-class=no-pdf \
+		README.rst \
+		-o README.pdf
+	@echo "Done"
+	@echo
+
+
+###############################################################################
+# Homebrew
+###############################################################################
+
+brew-deps:
+	extras/brew-deps.py
+
+brew-test:
+	- brew uninstall httpie
+	brew install --build-from-source ./extras/httpie.rb
+	brew test httpie
+	brew audit --strict httpie

extras/brew-deps.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""
+Generate Ruby code with URLs and file hashes for packages from PyPi
+(i.e., httpie itself as well as its dependencies) to be included
+in the Homebrew formula after a new release of HTTPie has been published
+on PyPi.
+
+<https://github.com/Homebrew/homebrew-core/blob/master/Formula/httpie.rb>
+
+"""
+import hashlib
+import requests
+
+
+PACKAGES = [
+    'httpie',
+    'Pygments',
+    'requests',
+    'requests-toolbelt',
+    'certifi',
+    'urllib3',
+    'idna',
+    'chardet',
+    'PySocks',
+]
+
+
+def get_package_meta(package_name):
+    api_url = f'https://pypi.python.org/pypi/{package_name}/json'
+    resp = requests.get(api_url).json()
+    hasher = hashlib.sha256()
+    for release in resp['urls']:
+        download_url = release['url']
+        if download_url.endswith('.tar.gz'):
+            hasher.update(requests.get(download_url).content)
+            return {
+                'name': package_name,
+                'url': download_url,
+                'sha256': hasher.hexdigest(),
+            }
+    else:
+        raise RuntimeError(f'{package_name}: download not found: {resp}')
+
+
+def main():
+    package_meta_map = {
+        package_name: get_package_meta(package_name)
+        for package_name in PACKAGES
+    }
+    httpie_meta = package_meta_map.pop('httpie')
+    print()
+    print('  url "{url}"'.format(url=httpie_meta['url']))
+    print('  sha256 "{sha256}"'.format(sha256=httpie_meta['sha256']))
+    print()
+    for dep_meta in package_meta_map.values():
+        print('  resource "{name}" do'.format(name=dep_meta['name']))
+        print('    url "{url}"'.format(url=dep_meta['url']))
+        print('    sha256 "{sha256}"'.format(sha256=dep_meta['sha256']))
+        print('  end')
+        print('')
+
+
+if __name__ == '__main__':
+    main()

extras/httpie-completion.bash

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+
+_http_complete() {
+    local cur_word=${COMP_WORDS[COMP_CWORD]}
+    local prev_word=${COMP_WORDS[COMP_CWORD - 1]}
+
+    if [[ "$cur_word" == -*  ]]; then
+        _http_complete_options "$cur_word"
+    fi
+}
+
+complete -o default -F _http_complete http
+
+_http_complete_options() {
+    local cur_word=$1
+    local options="-j --json -f --form --pretty -s --style -p --print
+    -v --verbose -h --headers -b --body -S --stream -o --output -d --download
+    -c --continue --session --session-read-only -a --auth --auth-type --proxy
+    --follow --verify --cert --cert-key --timeout --check-status --ignore-stdin
+    --help --version --traceback --debug"
+    COMPREPLY=( $( compgen -W "$options" -- "$cur_word" ) )
+}

extras/httpie-completion.fish

@@ -0,0 +1,59 @@
+function __fish_httpie_auth_types
+  echo "basic"\t"Basic HTTP auth"
+  echo "digest"\t"Digest HTTP auth"
+end
+
+function __fish_httpie_styles
+  echo "autumn"
+  echo "borland"
+  echo "bw"
+  echo "colorful"
+  echo "default"
+  echo "emacs"
+  echo "friendly"
+  echo "fruity"
+  echo "igor"
+  echo "manni"
+  echo "monokai"
+  echo "murphy"
+  echo "native"
+  echo "paraiso-dark"
+  echo "paraiso-light"
+  echo "pastie"
+  echo "perldoc"
+  echo "rrt"
+  echo "solarized"
+  echo "tango"
+  echo "trac"
+  echo "vim"
+  echo "vs"
+  echo "xcode"
+end
+
+complete -x -c http -s s -l style        -d 'Output coloring style (default is "monokai")' -A -a '(__fish_httpie_styles)'
+complete    -c http -s f -l form         -d 'Data items from the command line are serialized as form fields'
+complete    -c http -s j -l json         -d '(default) Data items from the command line are serialized as a JSON object'
+complete -x -c http      -l pretty       -d 'Controls output processing' -a "all colors format none" -A
+complete -x -c http -s p -l print        -d 'String specifying what the output should contain'
+complete    -c http -s v -l verbose      -d 'Print the whole request as well as the response'
+complete    -c http -s h -l headers      -d 'Print only the response headers'
+complete    -c http -s b -l body         -d 'Print only the response body'
+complete    -c http -s S -l stream       -d 'Always stream the output by line'
+complete    -c http -s o -l output       -d 'Save output to FILE'
+complete    -c http -s d -l download     -d 'Do not print the response body to stdout'
+complete    -c http -s c -l continue     -d 'Resume an interrupted download'
+complete -x -c http      -l session      -d 'Create, or reuse and update a session'
+complete -x -c http -s a -l auth         -d 'If only the username is provided (-a username), HTTPie will prompt for the password'
+complete -x -c http      -l auth-type    -d 'The authentication mechanism to be used' -a '(__fish_httpie_auth_types)' -A
+complete -x -c http      -l proxy        -d 'String mapping protocol to the URL of the proxy'
+complete    -c http      -l follow       -d 'Allow full redirects'
+complete -x -c http      -l verify       -d 'SSL cert verification'
+complete    -c http      -l cert         -d 'SSL cert'
+complete    -c http      -l cert-key     -d 'Private SSL cert key'
+complete -x -c http      -l timeout      -d 'Connection timeout in seconds'
+complete    -c http      -l check-status -d 'Error with non-200 HTTP status code'
+complete    -c http      -l ignore-stdin -d 'Do not attempt to read stdin'
+complete    -c http      -l help         -d 'Show help'
+complete    -c http      -l version      -d 'Show version'
+complete    -c http      -l traceback    -d 'Prints exception traceback should one occur'
+complete    -c http      -l debug        -d 'Show debugging information'

extras/httpie.rb

@@ -0,0 +1,68 @@
+# The latest Homebrew formula as submitted to Homebrew/homebrew-core.
+# Only useful for testing until it gets accepted by homebrew maintainers.
+# (It will need to be updated from the repo version before next release.)
+#
+# https://github.com/Homebrew/homebrew-core/blob/master/Formula/httpie.rb
+#
+class Httpie < Formula
+  include Language::Python::Virtualenv
+
+  desc "User-friendly cURL replacement (command-line HTTP client)"
+  homepage "https://httpie.org/"
+  url "https://files.pythonhosted.org/packages/37/6c/0d050f49e3b2bac589367d0c3aee9c078e23c6914b0210ffc0117218bdaf/httpie-2.2.0.tar.gz"
+  sha256 "31ac28088ee6a0b6f3ba7a53379000c4d1910c1708c9ff768f84b111c14405a0"
+  head "https://github.com/jakubroztocil/httpie.git"
+
+  bottle do
+    cellar :any_skip_relocation
+    sha256 "25f0e58f81a2cdd9cba772f07d67591533b4b31a2b970a356701aa046d4d9638" => :catalina
+    sha256 "be158ebb4cfd327ebea02f7b8b8d63d093e474cd303eafff4a2b56b0611983a2" => :mojave
+    sha256 "f331edb94183bfc5fa9de4b4abf148cc91a3a8b3c0e24cc1f5e6b0a4172dd34d" => :high_sierra
+  end
+
+  depends_on "python@3.8"
+
+  resource "Pygments" do
+    url "https://files.pythonhosted.org/packages/6e/4d/4d2fe93a35dfba417311a4ff627489a947b01dc0cc377a3673c00cf7e4b2/Pygments-2.6.1.tar.gz"
+    sha256 "647344a061c249a3b74e230c739f434d7ea4d8b1d5f3721bc0f3558049b38f44"
+  end
+
+  resource "requests" do
+    url "https://files.pythonhosted.org/packages/da/67/672b422d9daf07365259958912ba533a0ecab839d4084c487a5fe9a5405f/requests-2.24.0.tar.gz"
+    sha256 "b3559a131db72c33ee969480840fff4bb6dd111de7dd27c8ee1f820f4f00231b"
+  end
+
+  resource "certifi" do
+    url "https://files.pythonhosted.org/packages/b4/19/53433f37a31543364c8676f30b291d128cdf4cd5b31b755b7890f8e89ac8/certifi-2020.4.5.2.tar.gz"
+    sha256 "5ad7e9a056d25ffa5082862e36f119f7f7cec6457fa07ee2f8c339814b80c9b1"
+  end
+
+  resource "urllib3" do
+    url "https://files.pythonhosted.org/packages/05/8c/40cd6949373e23081b3ea20d5594ae523e681b6f472e600fbc95ed046a36/urllib3-1.25.9.tar.gz"
+    sha256 "3018294ebefce6572a474f0604c2021e33b3fd8006ecd11d62107a5d2a963527"
+  end
+
+  resource "idna" do
+    url "https://files.pythonhosted.org/packages/cb/19/57503b5de719ee45e83472f339f617b0c01ad75cba44aba1e4c97c2b0abd/idna-2.9.tar.gz"
+    sha256 "7588d1c14ae4c77d74036e8c22ff447b26d0fde8f007354fd48a7814db15b7cb"
+  end
+
+  resource "chardet" do
+    url "https://files.pythonhosted.org/packages/fc/bb/a5768c230f9ddb03acc9ef3f0d4a3cf93462473795d18e9535498c8f929d/chardet-3.0.4.tar.gz"
+    sha256 "84ab92ed1c4d4f16916e05906b6b75a6c0fb5db821cc65e70cbd64a3e2a5eaae"
+  end
+
+  resource "PySocks" do
+    url "https://files.pythonhosted.org/packages/bd/11/293dd436aea955d45fc4e8a35b6ae7270f5b8e00b53cf6c024c83b657a11/PySocks-1.7.1.tar.gz"
+    sha256 "3f8804571ebe159c380ac6de37643bb4685970655d3bba243530d6558b799aa0"
+  end
+
+  def install
+    virtualenv_install_with_resources
+  end
+
+  test do
+    raw_url = "https://raw.githubusercontent.com/Homebrew/homebrew-core/master/Formula/httpie.rb"
+    assert_match "PYTHONPATH", shell_output("#{bin}/http --ignore-stdin #{raw_url}")
+  end
+end

httpie/__init__.py

@@ -1,19 +1,8 @@
 """
-HTTPie - a CLI, cURL-like tool for humans.
+HTTPie: command-line HTTP client for the API era.
 
 """
+
+__version__ = '2.3.0'
 __author__ = 'Jakub Roztocil'
-__version__ = '0.4.1'
 __licence__ = 'BSD'
-
-
-class ExitStatus:
-    """Exit status code constants."""
-    OK = 0
-    ERROR = 1
-    ERROR_TIMEOUT = 2
-
-    # Used only when requested with --check-status:
-    ERROR_HTTP_3XX = 3
-    ERROR_HTTP_4XX = 4
-    ERROR_HTTP_5XX = 5

httpie/__main__.py

@@ -3,8 +3,18 @@
 
 """
 import sys
-from .core import main
+
+
+def main():
+    try:
+        from .core import main
+        exit_status = main()
+    except KeyboardInterrupt:
+        from httpie.status import ExitStatus
+        exit_status = ExitStatus.ERROR_CTRL_C
+
+    sys.exit(exit_status.value)
 
 
 if __name__ == '__main__':
-    sys.exit(main())
+    main()

httpie/cli.py

@@ -1,352 +0,0 @@
-"""CLI arguments definition.
-
-NOTE: the CLI interface may change before reaching v1.0.
-TODO: make the options config friendly, i.e., no mutually exclusive groups to
-      allow options overwriting.
-
-"""
-from argparse import FileType, OPTIONAL, ZERO_OR_MORE, SUPPRESS
-
-from . import __doc__
-from . import __version__
-from .compat import is_windows
-from .sessions import DEFAULT_SESSIONS_DIR, Session
-from .output import AVAILABLE_STYLES, DEFAULT_STYLE
-from .input import (Parser, AuthCredentialsArgType, KeyValueArgType,
-                    SEP_PROXY, SEP_CREDENTIALS, SEP_GROUP_ITEMS,
-                    OUT_REQ_HEAD, OUT_REQ_BODY, OUT_RESP_HEAD,
-                    OUT_RESP_BODY, OUTPUT_OPTIONS,
-                    PRETTY_MAP, PRETTY_STDOUT_TTY_ONLY, RegexValidator)
-
-
-def _(text):
-    """Normalize whitespace."""
-    return ' '.join(text.strip().split())
-
-
-parser = Parser(
-    description='%s <http://httpie.org>' % __doc__.strip(),
-    epilog='For every --option there is a --no-option'
-           ' that reverts the option to its default value.\n\n'
-           'Suggestions and bug reports are greatly appreciated:\n'
-           'https://github.com/jkbr/httpie/issues'
-)
-
-
-###############################################################################
-# Positional arguments.
-###############################################################################
-
-positional = parser.add_argument_group(
-    title='Positional arguments',
-    description=_('''
-        These arguments come after any flags and in the
-        order they are listed here. Only URL is required.
-    ''')
-)
-positional.add_argument(
-    'method', metavar='METHOD',
-    nargs=OPTIONAL,
-    default=None,
-    help=_('''
-        The HTTP method to be used for the request
-        (GET, POST, PUT, DELETE, PATCH, ...).
-        If this argument is omitted, then HTTPie
-        will guess the HTTP method. If there is some
-        data to be sent, then it will be POST, otherwise GET.
-    ''')
-)
-positional.add_argument(
-    'url', metavar='URL',
-    help=_('''
-        The protocol defaults to http:// if the
-        URL does not include one.
-    ''')
-)
-positional.add_argument(
-    'items', metavar='REQUEST ITEM',
-    nargs=ZERO_OR_MORE,
-    type=KeyValueArgType(*SEP_GROUP_ITEMS),
-    help=_('''
-        A key-value pair whose type is defined by the
-        separator used. It can be an HTTP header (header:value),
-        a data field to be used in the request body (field_name=value),
-        a raw JSON data field (field_name:=value),
-        a query parameter (name==value),
-        or a file field (field_name@/path/to/file).
-        You can use a backslash to escape a colliding
-        separator in the field name.
-    ''')
-)
-
-
-###############################################################################
-# Content type.
-###############################################################################
-
-content_type = parser.add_argument_group(
-    title='Predefined content types',
-    description=None
-)
-
-content_type.add_argument(
-    '--json', '-j', action='store_true',
-    help=_('''
-        (default) Data items from the command
-        line are serialized as a JSON object.
-        The Content-Type and Accept headers
-        are set to application/json (if not specified).
-    ''')
-)
-content_type.add_argument(
-    '--form', '-f', action='store_true',
-    help=_('''
-        Data items from the command line are serialized as form fields.
-        The Content-Type is set to application/x-www-form-urlencoded
-        (if not specified).
-        The presence of any file fields results
-        in a multipart/form-data request.
-     ''')
-)
-
-
-###############################################################################
-# Output processing
-###############################################################################
-
-output_processing = parser.add_argument_group(title='Output processing')
-
-output_processing.add_argument(
-    '--output', '-o', type=FileType('w+b'),
-    metavar='FILE',
-    help=SUPPRESS if not is_windows else _(
-        '''
-        Save output to FILE.
-        This option is a replacement for piping output to FILE,
-        which would on Windows result in corrupted data
-        being saved.
-
-        '''
-    )
-)
-output_processing.add_argument(
-    '--pretty', dest='prettify', default=PRETTY_STDOUT_TTY_ONLY,
-    choices=sorted(PRETTY_MAP.keys()),
-    help=_('''
-        Controls output processing. The value can be "none" to not prettify
-        the output (default for redirected output), "all" to apply both colors
-        and formatting
-        (default for terminal output), "colors", or "format".
-    ''')
-)
-output_processing.add_argument(
-    '--style', '-s', dest='style', default=DEFAULT_STYLE, metavar='STYLE',
-    choices=AVAILABLE_STYLES,
-    help=_('''
-        Output coloring style. One of %s. Defaults to "%s".
-        For this option to work properly, please make sure that the
-        $TERM environment variable is set to "xterm-256color" or similar
-        (e.g., via `export TERM=xterm-256color' in your ~/.bashrc).
-    ''') % (', '.join(sorted(AVAILABLE_STYLES)), DEFAULT_STYLE)
-)
-
-
-###############################################################################
-# Output options
-###############################################################################
-output_options = parser.add_argument_group(title='Output options')
-
-output_options.add_argument(
-    '--print', '-p', dest='output_options', metavar='WHAT',
-    help=_('''
-        String specifying what the output should contain:
-        "{request_headers}" stands for the request headers,  and
-        "{request_body}" for the request body.
-        "{response_headers}" stands for the response headers and
-        "{response_body}" for response the body.
-        The default behaviour is "hb" (i.e., the response
-        headers and body is printed), if standard output is not redirected.
-        If the output is piped to another program or to a file,
-        then only the body is printed by default.
-        '''.format(request_headers=OUT_REQ_HEAD,
-                   request_body=OUT_REQ_BODY,
-                   response_headers=OUT_RESP_HEAD,
-                   response_body=OUT_RESP_BODY,))
-)
-output_options.add_argument(
-    '--verbose', '-v', dest='output_options',
-    action='store_const', const=''.join(OUTPUT_OPTIONS),
-    help=_('''
-        Print the whole request as well as the response.
-        Shortcut for --print={0}.
-    '''.format(''.join(OUTPUT_OPTIONS)))
-)
-output_options.add_argument(
-    '--headers', '-h', dest='output_options',
-    action='store_const', const=OUT_RESP_HEAD,
-    help=_('''
-        Print only the response headers.
-        Shortcut for --print={0}.
-    '''.format(OUT_RESP_HEAD))
-)
-output_options.add_argument(
-    '--body', '-b', dest='output_options',
-    action='store_const', const=OUT_RESP_BODY,
-    help=_('''
-        Print only the response body.
-        Shortcut for --print={0}.
-    '''.format(OUT_RESP_BODY))
-)
-
-output_options.add_argument(
-    '--stream', '-S', action='store_true', default=False,
-    help=_('''
-    Always stream the output by line, i.e., behave like `tail -f'.
-
-    Without --stream and with --pretty (either set or implied),
-    HTTPie fetches the whole response before it outputs the processed data.
-
-    Set this option when you want to continuously display a prettified
-    long-lived response, such as one from the Twitter streaming API.
-
-    It is useful also without --pretty: It ensures that the output is flushed
-    more often and in smaller chunks.
-
-    ''')
-)
-
-
-###############################################################################
-# Sessions
-###############################################################################
-sessions = parser.add_argument_group(title='Sessions')\
-                 .add_mutually_exclusive_group(required=False)
-
-sessions.add_argument(
-    '--session', metavar='SESSION_NAME', type=RegexValidator(
-        Session.VALID_NAME_PATTERN,
-        'Session name contains invalid characters.'
-    ),
-    help=_('''
-    Create, or reuse and update a session.
-    Within a session, custom headers, auth credential, as well as any
-    cookies sent by the server persist between requests.
-    Session files are stored in %s/<HOST>/<SESSION_NAME>.json.
-    ''' % DEFAULT_SESSIONS_DIR)
-)
-sessions.add_argument(
-    '--session-read-only', metavar='SESSION_NAME',
-    help=_('''
-        Create or read a session without updating it form the
-        request/response exchange.
-    ''')
-)
-
-
-###############################################################################
-# Authentication
-###############################################################################
-# ``requests.request`` keyword arguments.
-auth = parser.add_argument_group(title='Authentication')
-auth.add_argument(
-    '--auth', '-a', metavar='USER[:PASS]',
-    type=AuthCredentialsArgType(SEP_CREDENTIALS),
-    help=_('''
-        If only the username is provided (-a username),
-        HTTPie will prompt for the password.
-    '''),
-)
-
-auth.add_argument(
-    '--auth-type', choices=['basic', 'digest'], default='basic',
-    help=_('''
-        The authentication mechanism to be used.
-        Defaults to "basic".
-    ''')
-)
-
-
-# Network
-#############################################
-
-network = parser.add_argument_group(title='Network')
-
-network.add_argument(
-    '--proxy', default=[], action='append', metavar='PROTOCOL:HOST',
-    type=KeyValueArgType(SEP_PROXY),
-    help=_('''
-        String mapping protocol to the URL of the proxy
-        (e.g. http:foo.bar:3128). You can specify multiple
-        proxies with different protocols.
-    ''')
-)
-network.add_argument(
-    '--follow', default=False, action='store_true',
-    help=_('''
-        Set this flag if full redirects are allowed
-        (e.g. re-POST-ing of data at new ``Location``)
-    ''')
-)
-network.add_argument(
-    '--verify', default='yes',
-    help=_('''
-        Set to "no" to skip checking the host\'s SSL certificate.
-        You can also pass the  path to a CA_BUNDLE
-        file for private certs. You can also set
-        the REQUESTS_CA_BUNDLE  environment variable.
-        Defaults to "yes".
-    ''')
-)
-
-network.add_argument(
-    '--timeout', type=float, default=30, metavar='SECONDS',
-    help=_('''
-        The connection timeout of the request in seconds.
-        The default value is 30 seconds.
-    ''')
-)
-network.add_argument(
-    '--check-status', default=False, action='store_true',
-    help=_('''
-        By default, HTTPie exits with 0 when no network or other fatal
-        errors occur.
-
-        This flag instructs HTTPie to also check the HTTP status code and
-        exit with an error if the status indicates one.
-
-        When the server replies with a 4xx (Client Error) or 5xx
-        (Server Error) status code, HTTPie exits with 4 or 5 respectively.
-        If the response is a 3xx (Redirect) and --follow
-        hasn't been set, then the exit status is 3.
-
-        Also an error message is written to stderr if stdout is redirected.
-
-    ''')
-)
-
-
-###############################################################################
-# Troubleshooting
-###############################################################################
-
-troubleshooting = parser.add_argument_group(title='Troubleshooting')
-
-troubleshooting.add_argument(
-    '--help',
-    action='help', default=SUPPRESS,
-    help='Show this help message and exit'
-)
-troubleshooting.add_argument(
-    '--version', action='version', version=__version__)
-troubleshooting.add_argument(
-    '--traceback', action='store_true', default=False,
-    help='Prints exception traceback should one occur.'
-)
-troubleshooting.add_argument(
-    '--debug', action='store_true', default=False,
-    help=_('''
-        Prints exception traceback should one occur, and also other
-        information that is useful for debugging HTTPie itself and
-        for bug reports.
-    ''')
-)

httpie/cli/argparser.py

@@ -0,0 +1,444 @@
+import argparse
+import errno
+import os
+import re
+import sys
+from argparse import RawDescriptionHelpFormatter
+from textwrap import dedent
+from urllib.parse import urlsplit
+
+from requests.utils import get_netrc_auth
+
+from httpie.cli.argtypes import (
+    AuthCredentials, KeyValueArgType, PARSED_DEFAULT_FORMAT_OPTIONS,
+    parse_auth,
+    parse_format_options,
+)
+from httpie.cli.constants import (
+    HTTP_GET, HTTP_POST, OUTPUT_OPTIONS, OUTPUT_OPTIONS_DEFAULT,
+    OUTPUT_OPTIONS_DEFAULT_OFFLINE, OUTPUT_OPTIONS_DEFAULT_STDOUT_REDIRECTED,
+    OUT_RESP_BODY, PRETTY_MAP, PRETTY_STDOUT_TTY_ONLY, RequestType,
+    SEPARATOR_CREDENTIALS,
+    SEPARATOR_GROUP_ALL_ITEMS, SEPARATOR_GROUP_DATA_ITEMS, URL_SCHEME_RE,
+)
+from httpie.cli.exceptions import ParseError
+from httpie.cli.requestitems import RequestItems
+from httpie.context import Environment
+from httpie.plugins.registry import plugin_manager
+from httpie.utils import ExplicitNullAuth, get_content_type
+
+
+class HTTPieHelpFormatter(RawDescriptionHelpFormatter):
+    """A nicer help formatter.
+
+    Help for arguments can be indented and contain new lines.
+    It will be de-dented and arguments in the help
+    will be separated by a blank line for better readability.
+
+
+    """
+
+    def __init__(self, max_help_position=6, *args, **kwargs):
+        # A smaller indent for args help.
+        kwargs['max_help_position'] = max_help_position
+        super().__init__(*args, **kwargs)
+
+    def _split_lines(self, text, width):
+        text = dedent(text).strip() + '\n\n'
+        return text.splitlines()
+
+
+# TODO: refactor and design type-annotated data structures
+#       for raw args + parsed args and keep things immutable.
+class HTTPieArgumentParser(argparse.ArgumentParser):
+    """Adds additional logic to `argparse.ArgumentParser`.
+
+    Handles all input (CLI args, file args, stdin), applies defaults,
+    and performs extra validation.
+
+    """
+
+    def __init__(self, *args, formatter_class=HTTPieHelpFormatter, **kwargs):
+        kwargs['add_help'] = False
+        super().__init__(*args, formatter_class=formatter_class, **kwargs)
+        self.env = None
+        self.args = None
+        self.has_stdin_data = False
+
+    # noinspection PyMethodOverriding
+    def parse_args(
+        self,
+        env: Environment,
+        args=None,
+        namespace=None
+    ) -> argparse.Namespace:
+        self.env = env
+        self.args, no_options = super().parse_known_args(args, namespace)
+        if self.args.debug:
+            self.args.traceback = True
+        self.has_stdin_data = (
+            self.env.stdin
+            and not self.args.ignore_stdin
+            and not self.env.stdin_isatty
+        )
+        # Arguments processing and environment setup.
+        self._apply_no_options(no_options)
+        self._process_request_type()
+        self._process_download_options()
+        self._setup_standard_streams()
+        self._process_output_options()
+        self._process_pretty_options()
+        self._process_format_options()
+        self._guess_method()
+        self._parse_items()
+        if self.has_stdin_data:
+            self._body_from_file(self.env.stdin)
+        self._process_url()
+        self._process_auth()
+
+        if self.args.compress:
+            # TODO: allow --compress with --chunked / --multipart
+            if self.args.chunked:
+                self.error('cannot combine --compress and --chunked')
+            if self.args.multipart:
+                self.error('cannot combine --compress and --multipart')
+
+        return self.args
+
+    def _process_request_type(self):
+        request_type = self.args.request_type
+        self.args.json = request_type is RequestType.JSON
+        self.args.multipart = request_type is RequestType.MULTIPART
+        self.args.form = request_type in {
+            RequestType.FORM,
+            RequestType.MULTIPART,
+        }
+
+    def _process_url(self):
+        if not URL_SCHEME_RE.match(self.args.url):
+            if os.path.basename(self.env.program_name) == 'https':
+                scheme = 'https://'
+            else:
+                scheme = self.args.default_scheme + '://'
+
+            # See if we're using curl style shorthand for localhost (:3000/foo)
+            shorthand = re.match(r'^:(?!:)(\d*)(/?.*)$', self.args.url)
+            if shorthand:
+                port = shorthand.group(1)
+                rest = shorthand.group(2)
+                self.args.url = scheme + 'localhost'
+                if port:
+                    self.args.url += ':' + port
+                self.args.url += rest
+            else:
+                self.args.url = scheme + self.args.url
+
+    # noinspection PyShadowingBuiltins
+    def _print_message(self, message, file=None):
+        # Sneak in our stderr/stdout.
+        file = {
+            sys.stdout: self.env.stdout,
+            sys.stderr: self.env.stderr,
+            None: self.env.stderr
+        }.get(file, file)
+        if not hasattr(file, 'buffer') and isinstance(message, str):
+            message = message.encode(self.env.stdout_encoding)
+        super()._print_message(message, file)
+
+    def _setup_standard_streams(self):
+        """
+        Modify `env.stdout` and `env.stdout_isatty` based on args, if needed.
+
+        """
+
+        self.args.output_file_specified = bool(self.args.output_file)
+        if self.args.download:
+            # FIXME: Come up with a cleaner solution.
+            if not self.args.output_file and not self.env.stdout_isatty:
+                # Use stdout as the download output file.
+                self.args.output_file = self.env.stdout
+            # With `--download`, we write everything that would normally go to
+            # `stdout` to `stderr` instead. Let's replace the stream so that
+            # we don't have to use many `if`s throughout the codebase.
+            # The response body will be treated separately.
+            self.env.stdout = self.env.stderr
+            self.env.stdout_isatty = self.env.stderr_isatty
+
+        elif self.args.output_file:
+            # When not `--download`ing, then `--output` simply replaces
+            # `stdout`. The file is opened for appending, which isn't what
+            # we want in this case.
+            self.args.output_file.seek(0)
+            try:
+                self.args.output_file.truncate()
+            except IOError as e:
+                if e.errno == errno.EINVAL:
+                    # E.g. /dev/null on Linux.
+                    pass
+                else:
+                    raise
+            self.env.stdout = self.args.output_file
+            self.env.stdout_isatty = False
+
+        if self.args.quiet:
+            self.env.stderr = self.env.devnull
+            if not (self.args.output_file_specified and not self.args.download):
+                self.env.stdout = self.env.devnull
+
+    def _process_auth(self):
+        # TODO: refactor & simplify this method.
+        self.args.auth_plugin = None
+        default_auth_plugin = plugin_manager.get_auth_plugins()[0]
+        auth_type_set = self.args.auth_type is not None
+        url = urlsplit(self.args.url)
+
+        if self.args.auth is None and not auth_type_set:
+            if url.username is not None:
+                # Handle http://username:password@hostname/
+                username = url.username
+                password = url.password or ''
+                self.args.auth = AuthCredentials(
+                    key=username,
+                    value=password,
+                    sep=SEPARATOR_CREDENTIALS,
+                    orig=SEPARATOR_CREDENTIALS.join([username, password])
+                )
+
+        if self.args.auth is not None or auth_type_set:
+            if not self.args.auth_type:
+                self.args.auth_type = default_auth_plugin.auth_type
+            plugin = plugin_manager.get_auth_plugin(self.args.auth_type)()
+
+            if (not self.args.ignore_netrc
+                    and self.args.auth is None
+                    and plugin.netrc_parse):
+                # Only host needed, so it’s OK URL not finalized.
+                netrc_credentials = get_netrc_auth(self.args.url)
+                if netrc_credentials:
+                    self.args.auth = AuthCredentials(
+                        key=netrc_credentials[0],
+                        value=netrc_credentials[1],
+                        sep=SEPARATOR_CREDENTIALS,
+                        orig=SEPARATOR_CREDENTIALS.join(netrc_credentials)
+                    )
+
+            if plugin.auth_require and self.args.auth is None:
+                self.error('--auth required')
+
+            plugin.raw_auth = self.args.auth
+            self.args.auth_plugin = plugin
+            already_parsed = isinstance(self.args.auth, AuthCredentials)
+
+            if self.args.auth is None or not plugin.auth_parse:
+                self.args.auth = plugin.get_auth()
+            else:
+                if already_parsed:
+                    # from the URL
+                    credentials = self.args.auth
+                else:
+                    credentials = parse_auth(self.args.auth)
+
+                if (not credentials.has_password()
+                        and plugin.prompt_password):
+                    if self.args.ignore_stdin:
+                        # Non-tty stdin read by now
+                        self.error(
+                            'Unable to prompt for passwords because'
+                            ' --ignore-stdin is set.'
+                        )
+                    credentials.prompt_password(url.netloc)
+                self.args.auth = plugin.get_auth(
+                    username=credentials.key,
+                    password=credentials.value,
+                )
+        if not self.args.auth and self.args.ignore_netrc:
+            # Set a no-op auth to force requests to ignore .netrc
+            # <https://github.com/psf/requests/issues/2773#issuecomment-174312831>
+            self.args.auth = ExplicitNullAuth()
+
+    def _apply_no_options(self, no_options):
+        """For every `--no-OPTION` in `no_options`, set `args.OPTION` to
+        its default value. This allows for un-setting of options, e.g.,
+        specified in config.
+
+        """
+        invalid = []
+
+        for option in no_options:
+            if not option.startswith('--no-'):
+                invalid.append(option)
+                continue
+
+            # --no-option => --option
+            inverted = '--' + option[5:]
+            for action in self._actions:
+                if inverted in action.option_strings:
+                    setattr(self.args, action.dest, action.default)
+                    break
+            else:
+                invalid.append(option)
+
+        if invalid:
+            msg = 'unrecognized arguments: %s'
+            self.error(msg % ' '.join(invalid))
+
+    def _body_from_file(self, fd):
+        """There can only be one source of request data.
+
+        Bytes are always read.
+
+        """
+        if self.args.data or self.args.files:
+            self.error('Request body (from stdin or a file) and request '
+                       'data (key=value) cannot be mixed. Pass '
+                       '--ignore-stdin to let key/value take priority. '
+                       'See https://httpie.org/doc#scripting for details.')
+        self.args.data = getattr(fd, 'buffer', fd)
+
+    def _guess_method(self):
+        """Set `args.method` if not specified to either POST or GET
+        based on whether the request has data or not.
+
+        """
+        if self.args.method is None:
+            # Invoked as `http URL'.
+            assert not self.args.request_items
+            if self.has_stdin_data:
+                self.args.method = HTTP_POST
+            else:
+                self.args.method = HTTP_GET
+
+        # FIXME: False positive, e.g., "localhost" matches but is a valid URL.
+        elif not re.match('^[a-zA-Z]+$', self.args.method):
+            # Invoked as `http URL item+'. The URL is now in `args.method`
+            # and the first ITEM is now incorrectly in `args.url`.
+            try:
+                # Parse the URL as an ITEM and store it as the first ITEM arg.
+                self.args.request_items.insert(0, KeyValueArgType(
+                    *SEPARATOR_GROUP_ALL_ITEMS).__call__(self.args.url))
+
+            except argparse.ArgumentTypeError as e:
+                if self.args.traceback:
+                    raise
+                self.error(e.args[0])
+
+            else:
+                # Set the URL correctly
+                self.args.url = self.args.method
+                # Infer the method
+                has_data = (
+                    self.has_stdin_data
+                    or any(
+                        item.sep in SEPARATOR_GROUP_DATA_ITEMS
+                        for item in self.args.request_items)
+                )
+                self.args.method = HTTP_POST if has_data else HTTP_GET
+
+    def _parse_items(self):
+        """
+        Parse `args.request_items` into `args.headers`, `args.data`,
+        `args.params`, and `args.files`.
+
+        """
+        try:
+            request_items = RequestItems.from_args(
+                request_item_args=self.args.request_items,
+                as_form=self.args.form,
+            )
+        except ParseError as e:
+            if self.args.traceback:
+                raise
+            self.error(e.args[0])
+        else:
+            self.args.headers = request_items.headers
+            self.args.data = request_items.data
+            self.args.files = request_items.files
+            self.args.params = request_items.params
+            self.args.multipart_data = request_items.multipart_data
+
+        if self.args.files and not self.args.form:
+            # `http url @/path/to/file`
+            file_fields = list(self.args.files.keys())
+            if file_fields != ['']:
+                self.error(
+                    'Invalid file fields (perhaps you meant --form?): %s'
+                    % ','.join(file_fields))
+
+            fn, fd, ct = self.args.files['']
+            self.args.files = {}
+
+            self._body_from_file(fd)
+
+            if 'Content-Type' not in self.args.headers:
+                content_type = get_content_type(fn)
+                if content_type:
+                    self.args.headers['Content-Type'] = content_type
+
+    def _process_output_options(self):
+        """Apply defaults to output options, or validate the provided ones.
+
+        The default output options are stdout-type-sensitive.
+
+        """
+
+        def check_options(value, option):
+            unknown = set(value) - OUTPUT_OPTIONS
+            if unknown:
+                self.error('Unknown output options: {0}={1}'.format(
+                    option,
+                    ','.join(unknown)
+                ))
+
+        if self.args.verbose:
+            self.args.all = True
+
+        if self.args.output_options is None:
+            if self.args.verbose:
+                self.args.output_options = ''.join(OUTPUT_OPTIONS)
+            elif self.args.offline:
+                self.args.output_options = OUTPUT_OPTIONS_DEFAULT_OFFLINE
+            elif not self.env.stdout_isatty:
+                self.args.output_options = OUTPUT_OPTIONS_DEFAULT_STDOUT_REDIRECTED
+            else:
+                self.args.output_options = OUTPUT_OPTIONS_DEFAULT
+
+        if self.args.output_options_history is None:
+            self.args.output_options_history = self.args.output_options
+
+        check_options(self.args.output_options, '--print')
+        check_options(self.args.output_options_history, '--history-print')
+
+        if self.args.download and OUT_RESP_BODY in self.args.output_options:
+            # Response body is always downloaded with --download and it goes
+            # through a different routine, so we remove it.
+            self.args.output_options = str(
+                set(self.args.output_options) - set(OUT_RESP_BODY))
+
+    def _process_pretty_options(self):
+        if self.args.prettify == PRETTY_STDOUT_TTY_ONLY:
+            self.args.prettify = PRETTY_MAP[
+                'all' if self.env.stdout_isatty else 'none']
+        elif (self.args.prettify and self.env.is_windows
+              and self.args.output_file):
+            self.error('Only terminal output can be colorized on Windows.')
+        else:
+            # noinspection PyTypeChecker
+            self.args.prettify = PRETTY_MAP[self.args.prettify]
+
+    def _process_download_options(self):
+        if self.args.offline:
+            self.args.download = False
+            self.args.download_resume = False
+            return
+        if not self.args.download:
+            if self.args.download_resume:
+                self.error('--continue only works with --download')
+        if self.args.download_resume and not (
+                self.args.download and self.args.output_file):
+            self.error('--continue requires --output to be specified')
+
+    def _process_format_options(self):
+        parsed_options = PARSED_DEFAULT_FORMAT_OPTIONS
+        for options_group in self.args.format_options or []:
+            parsed_options = parse_format_options(options_group, defaults=parsed_options)
+        self.args.format_options = parsed_options

httpie/cli/argtypes.py

@@ -0,0 +1,244 @@
+import argparse
+import getpass
+import os
+import sys
+from copy import deepcopy
+from typing import List, Optional, Union
+
+from httpie.cli.constants import DEFAULT_FORMAT_OPTIONS, SEPARATOR_CREDENTIALS
+from httpie.sessions import VALID_SESSION_NAME_PATTERN
+
+
+class KeyValueArg:
+    """Base key-value pair parsed from CLI."""
+
+    def __init__(self, key: str, value: Optional[str], sep: str, orig: str):
+        self.key = key
+        self.value = value
+        self.sep = sep
+        self.orig = orig
+
+    def __eq__(self, other: 'KeyValueArg'):
+        return self.__dict__ == other.__dict__
+
+    def __repr__(self):
+        return repr(self.__dict__)
+
+
+class SessionNameValidator:
+
+    def __init__(self, error_message: str):
+        self.error_message = error_message
+
+    def __call__(self, value: str) -> str:
+        # Session name can be a path or just a name.
+        if (os.path.sep not in value
+                and not VALID_SESSION_NAME_PATTERN.search(value)):
+            raise argparse.ArgumentError(None, self.error_message)
+        return value
+
+
+class Escaped(str):
+    """Represents an escaped character."""
+
+    def __repr__(self):
+        return f"Escaped({repr(str(self))})"
+
+
+class KeyValueArgType:
+    """A key-value pair argument type used with `argparse`.
+
+    Parses a key-value arg and constructs a `KeyValueArg` instance.
+    Used for headers, form data, and other key-value pair types.
+
+    """
+
+    key_value_class = KeyValueArg
+
+    def __init__(self, *separators: str):
+        self.separators = separators
+        self.special_characters = set('\\')
+        for separator in separators:
+            self.special_characters.update(separator)
+
+    def __call__(self, s: str) -> KeyValueArg:
+        """Parse raw string arg  and return `self.key_value_class` instance.
+
+        The best of `self.separators` is determined (first found, longest).
+        Back slash escaped characters aren't considered as separators
+        (or parts thereof). Literal back slash characters have to be escaped
+        as well (r'\\').
+
+        """
+        tokens = self.tokenize(s)
+
+        # Sorting by length ensures that the longest one will be
+        # chosen as it will overwrite any shorter ones starting
+        # at the same position in the `found` dictionary.
+        separators = sorted(self.separators, key=len)
+
+        for i, token in enumerate(tokens):
+
+            if isinstance(token, Escaped):
+                continue
+
+            found = {}
+            for sep in separators:
+                pos = token.find(sep)
+                if pos != -1:
+                    found[pos] = sep
+
+            if found:
+                # Starting first, longest separator found.
+                sep = found[min(found.keys())]
+
+                key, value = token.split(sep, 1)
+
+                # Any preceding tokens are part of the key.
+                key = ''.join(tokens[:i]) + key
+
+                # Any following tokens are part of the value.
+                value += ''.join(tokens[i + 1:])
+
+                break
+
+        else:
+            raise argparse.ArgumentTypeError(f'{s!r} is not a valid value')
+
+        return self.key_value_class(key=key, value=value, sep=sep, orig=s)
+
+    def tokenize(self, s: str) -> List[Union[str, Escaped]]:
+        r"""Tokenize the raw arg string
+
+        There are only two token types - strings and escaped characters:
+
+        >>> KeyValueArgType('=').tokenize(r'foo\=bar\\baz')
+        ['foo', Escaped('='), 'bar', Escaped('\\'), 'baz']
+
+        """
+        tokens = ['']
+        characters = iter(s)
+        for char in characters:
+            if char == '\\':
+                char = next(characters, '')
+                if char not in self.special_characters:
+                    tokens[-1] += '\\' + char
+                else:
+                    tokens.extend([Escaped(char), ''])
+            else:
+                tokens[-1] += char
+        return tokens
+
+
+class AuthCredentials(KeyValueArg):
+    """Represents parsed credentials."""
+
+    def has_password(self) -> bool:
+        return self.value is not None
+
+    def prompt_password(self, host: str):
+        prompt_text = f'http: password for {self.key}@{host}: '
+        try:
+            self.value = self._getpass(prompt_text)
+        except (EOFError, KeyboardInterrupt):
+            sys.stderr.write('\n')
+            sys.exit(0)
+
+    @staticmethod
+    def _getpass(prompt):
+        # To allow easy mocking.
+        return getpass.getpass(str(prompt))
+
+
+class AuthCredentialsArgType(KeyValueArgType):
+    """A key-value arg type that parses credentials."""
+
+    key_value_class = AuthCredentials
+
+    def __call__(self, s):
+        """Parse credentials from `s`.
+
+        ("username" or "username:password").
+
+        """
+        try:
+            return super().__call__(s)
+        except argparse.ArgumentTypeError:
+            # No password provided, will prompt for it later.
+            return self.key_value_class(
+                key=s,
+                value=None,
+                sep=SEPARATOR_CREDENTIALS,
+                orig=s
+            )
+
+
+parse_auth = AuthCredentialsArgType(SEPARATOR_CREDENTIALS)
+
+
+def readable_file_arg(filename):
+    try:
+        with open(filename, 'rb'):
+            return filename
+    except IOError as ex:
+        raise argparse.ArgumentTypeError(f'{filename}: {ex.args[1]}')
+
+
+def parse_format_options(s: str, defaults: Optional[dict]) -> dict:
+    """
+    Parse `s` and update `defaults` with the parsed values.
+
+    >>> parse_format_options(
+    ... defaults={'json': {'indent': 4, 'sort_keys': True}},
+    ... s='json.indent:2,json.sort_keys:False',
+    ... )
+    {'json': {'indent': 2, 'sort_keys': False}}
+
+    """
+    value_map = {
+        'true': True,
+        'false': False,
+    }
+    options = deepcopy(defaults or {})
+    for option in s.split(','):
+        try:
+            path, value = option.lower().split(':')
+            section, key = path.split('.')
+        except ValueError:
+            raise argparse.ArgumentTypeError(f'invalid option {option!r}')
+
+        if value in value_map:
+            parsed_value = value_map[value]
+        else:
+            if value.isnumeric():
+                parsed_value = int(value)
+            else:
+                parsed_value = value
+
+        if defaults is None:
+            options.setdefault(section, {})
+        else:
+            try:
+                default_value = defaults[section][key]
+            except KeyError:
+                raise argparse.ArgumentTypeError(
+                    f'invalid key {path!r}')
+
+            default_type, parsed_type = type(default_value), type(parsed_value)
+            if parsed_type is not default_type:
+                raise argparse.ArgumentTypeError(
+                    'invalid value'
+                    f' {value!r} in {option!r}'
+                    f' (expected {default_type.__name__}'
+                    f' got {parsed_type.__name__})'
+                )
+
+        options[section][key] = parsed_value
+
+    return options
+
+
+PARSED_DEFAULT_FORMAT_OPTIONS = parse_format_options(
+    s=','.join(DEFAULT_FORMAT_OPTIONS),
+    defaults=None,
+)

httpie/cli/constants.py

@@ -0,0 +1,120 @@
+"""Parsing and processing of CLI input (args, auth credentials, files, stdin).
+
+"""
+import enum
+import re
+
+
+# TODO: Use MultiDict for headers once added to `requests`.
+# <https://github.com/jakubroztocil/httpie/issues/130>
+
+
+# ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
+# <https://tools.ietf.org/html/rfc3986#section-3.1>
+from enum import Enum
+
+
+URL_SCHEME_RE = re.compile(r'^[a-z][a-z0-9.+-]*://', re.IGNORECASE)
+
+HTTP_POST = 'POST'
+HTTP_GET = 'GET'
+
+# Various separators used in args
+SEPARATOR_HEADER = ':'
+SEPARATOR_HEADER_EMPTY = ';'
+SEPARATOR_CREDENTIALS = ':'
+SEPARATOR_PROXY = ':'
+SEPARATOR_DATA_STRING = '='
+SEPARATOR_DATA_RAW_JSON = ':='
+SEPARATOR_FILE_UPLOAD = '@'
+SEPARATOR_FILE_UPLOAD_TYPE = ';type='  # in already parsed file upload path only
+SEPARATOR_DATA_EMBED_FILE_CONTENTS = '=@'
+SEPARATOR_DATA_EMBED_RAW_JSON_FILE = ':=@'
+SEPARATOR_QUERY_PARAM = '=='
+
+# Separators that become request data
+SEPARATOR_GROUP_DATA_ITEMS = frozenset({
+    SEPARATOR_DATA_STRING,
+    SEPARATOR_DATA_RAW_JSON,
+    SEPARATOR_FILE_UPLOAD,
+    SEPARATOR_DATA_EMBED_FILE_CONTENTS,
+    SEPARATOR_DATA_EMBED_RAW_JSON_FILE
+})
+
+SEPARATORS_GROUP_MULTIPART = frozenset({
+    SEPARATOR_DATA_STRING,
+    SEPARATOR_DATA_EMBED_FILE_CONTENTS,
+    SEPARATOR_FILE_UPLOAD,
+})
+
+# Separators for items whose value is a filename to be embedded
+SEPARATOR_GROUP_DATA_EMBED_ITEMS = frozenset({
+    SEPARATOR_DATA_EMBED_FILE_CONTENTS,
+    SEPARATOR_DATA_EMBED_RAW_JSON_FILE,
+})
+
+# Separators for raw JSON items
+SEPARATOR_GROUP_RAW_JSON_ITEMS = frozenset([
+    SEPARATOR_DATA_RAW_JSON,
+    SEPARATOR_DATA_EMBED_RAW_JSON_FILE,
+])
+
+# Separators allowed in ITEM arguments
+SEPARATOR_GROUP_ALL_ITEMS = frozenset({
+    SEPARATOR_HEADER,
+    SEPARATOR_HEADER_EMPTY,
+    SEPARATOR_QUERY_PARAM,
+    SEPARATOR_DATA_STRING,
+    SEPARATOR_DATA_RAW_JSON,
+    SEPARATOR_FILE_UPLOAD,
+    SEPARATOR_DATA_EMBED_FILE_CONTENTS,
+    SEPARATOR_DATA_EMBED_RAW_JSON_FILE,
+})
+
+# Output options
+OUT_REQ_HEAD = 'H'
+OUT_REQ_BODY = 'B'
+OUT_RESP_HEAD = 'h'
+OUT_RESP_BODY = 'b'
+
+OUTPUT_OPTIONS = frozenset({
+    OUT_REQ_HEAD,
+    OUT_REQ_BODY,
+    OUT_RESP_HEAD,
+    OUT_RESP_BODY
+})
+
+# Pretty
+PRETTY_MAP = {
+    'all': ['format', 'colors'],
+    'colors': ['colors'],
+    'format': ['format'],
+    'none': []
+}
+PRETTY_STDOUT_TTY_ONLY = object()
+
+
+DEFAULT_FORMAT_OPTIONS = [
+    'headers.sort:true',
+    'json.format:true',
+    'json.indent:4',
+    'json.sort_keys:true',
+]
+SORTED_FORMAT_OPTIONS = [
+    'headers.sort:true',
+    'json.sort_keys:true',
+]
+SORTED_FORMAT_OPTIONS_STRING = ','.join(SORTED_FORMAT_OPTIONS)
+UNSORTED_FORMAT_OPTIONS_STRING = ','.join(
+    option.replace('true', 'false') for option in SORTED_FORMAT_OPTIONS)
+
+# Defaults
+OUTPUT_OPTIONS_DEFAULT = OUT_RESP_HEAD + OUT_RESP_BODY
+OUTPUT_OPTIONS_DEFAULT_STDOUT_REDIRECTED = OUT_RESP_BODY
+OUTPUT_OPTIONS_DEFAULT_OFFLINE = OUT_REQ_HEAD + OUT_REQ_BODY
+
+
+class RequestType(enum.Enum):
+    FORM = enum.auto()
+    MULTIPART = enum.auto()
+    JSON = enum.auto()

httpie/cli/definition.py

@@ -0,0 +1,796 @@
+"""
+CLI arguments definition.
+
+"""
+from argparse import (FileType, OPTIONAL, SUPPRESS, ZERO_OR_MORE)
+from textwrap import dedent, wrap
+
+from httpie import __doc__, __version__
+from httpie.cli.argparser import HTTPieArgumentParser
+from httpie.cli.argtypes import (
+    KeyValueArgType, SessionNameValidator,
+    readable_file_arg,
+)
+from httpie.cli.constants import (
+    DEFAULT_FORMAT_OPTIONS, OUTPUT_OPTIONS,
+    OUTPUT_OPTIONS_DEFAULT, OUT_REQ_BODY, OUT_REQ_HEAD,
+    OUT_RESP_BODY, OUT_RESP_HEAD, PRETTY_MAP, PRETTY_STDOUT_TTY_ONLY,
+    RequestType, SEPARATOR_GROUP_ALL_ITEMS, SEPARATOR_PROXY,
+    SORTED_FORMAT_OPTIONS_STRING,
+    UNSORTED_FORMAT_OPTIONS_STRING,
+)
+from httpie.output.formatters.colors import (
+    AUTO_STYLE, AVAILABLE_STYLES, DEFAULT_STYLE,
+)
+from httpie.plugins.builtin import BuiltinAuthPlugin
+from httpie.plugins.registry import plugin_manager
+from httpie.sessions import DEFAULT_SESSIONS_DIR
+from httpie.ssl import AVAILABLE_SSL_VERSION_ARG_MAPPING, DEFAULT_SSL_CIPHERS
+
+
+parser = HTTPieArgumentParser(
+    prog='http',
+    description='%s <https://httpie.org>' % __doc__.strip(),
+    epilog=dedent('''
+    For every --OPTION there is also a --no-OPTION that reverts OPTION
+    to its default value.
+
+    Suggestions and bug reports are greatly appreciated:
+
+        https://github.com/jakubroztocil/httpie/issues
+
+    '''),
+)
+
+#######################################################################
+# Positional arguments.
+#######################################################################
+
+positional = parser.add_argument_group(
+    title='Positional Arguments',
+    description=dedent('''
+    These arguments come after any flags and in the order they are listed here.
+    Only URL is required.
+
+    ''')
+)
+positional.add_argument(
+    dest='method',
+    metavar='METHOD',
+    nargs=OPTIONAL,
+    default=None,
+    help='''
+    The HTTP method to be used for the request (GET, POST, PUT, DELETE, ...).
+
+    This argument can be omitted in which case HTTPie will use POST if there
+    is some data to be sent, otherwise GET:
+
+        $ http example.org               # => GET
+        $ http example.org hello=world   # => POST
+
+    '''
+)
+positional.add_argument(
+    dest='url',
+    metavar='URL',
+    help='''
+    The scheme defaults to 'http://' if the URL does not include one.
+    (You can override this with: --default-scheme=https)
+
+    You can also use a shorthand for localhost
+
+        $ http :3000                    # => http://localhost:3000
+        $ http :/foo                    # => http://localhost/foo
+
+    '''
+)
+positional.add_argument(
+    dest='request_items',
+    metavar='REQUEST_ITEM',
+    nargs=ZERO_OR_MORE,
+    default=None,
+    type=KeyValueArgType(*SEPARATOR_GROUP_ALL_ITEMS),
+    help=r'''
+    Optional key-value pairs to be included in the request. The separator used
+    determines the type:
+
+    ':' HTTP headers:
+
+        Referer:http://httpie.org  Cookie:foo=bar  User-Agent:bacon/1.0
+
+    '==' URL parameters to be appended to the request URI:
+
+        search==httpie
+
+    '=' Data fields to be serialized into a JSON object (with --json, -j)
+        or form data (with --form, -f):
+
+        name=HTTPie  language=Python  description='CLI HTTP client'
+
+    ':=' Non-string JSON data fields (only with --json, -j):
+
+        awesome:=true  amount:=42  colors:='["red", "green", "blue"]'
+
+    '@' Form file fields (only with --form or --multipart):
+
+        cv@~/Documents/CV.pdf
+        cv@'~/Documents/CV.pdf;type=application/pdf'
+
+    '=@' A data field like '=', but takes a file path and embeds its content:
+
+         essay=@Documents/essay.txt
+
+    ':=@' A raw JSON field like ':=', but takes a file path and embeds its content:
+
+        package:=@./package.json
+
+    You can use a backslash to escape a colliding separator in the field name:
+
+        field-name-with\:colon=value
+
+    '''
+)
+
+#######################################################################
+# Content type.
+#######################################################################
+
+content_type = parser.add_argument_group(
+    title='Predefined Content Types',
+    description=None
+)
+
+content_type.add_argument(
+    '--json', '-j',
+    action='store_const',
+    const=RequestType.JSON,
+    dest='request_type',
+    help='''
+    (default) Data items from the command line are serialized as a JSON object.
+    The Content-Type and Accept headers are set to application/json
+    (if not specified).
+
+    '''
+)
+content_type.add_argument(
+    '--form', '-f',
+    action='store_const',
+    const=RequestType.FORM,
+    dest='request_type',
+    help='''
+    Data items from the command line are serialized as form fields.
+
+    The Content-Type is set to application/x-www-form-urlencoded (if not
+    specified). The presence of any file fields results in a
+    multipart/form-data request.
+
+    '''
+)
+content_type.add_argument(
+    '--multipart',
+    action='store_const',
+    const=RequestType.MULTIPART,
+    dest='request_type',
+    help='''
+    Similar to --form, but always sends a multipart/form-data
+    request (i.e., even without files).
+
+    '''
+)
+content_type.add_argument(
+    '--boundary',
+    help='''
+    Specify a custom boundary string for multipart/form-data requests.
+    Only has effect only together with --form.
+
+    '''
+)
+
+
+#######################################################################
+# Content processing.
+#######################################################################
+
+content_processing = parser.add_argument_group(
+    title='Content Processing Options',
+    description=None
+)
+
+content_processing.add_argument(
+    '--compress', '-x',
+    action='count',
+    default=0,
+    help='''
+    Content compressed (encoded) with Deflate algorithm.
+    The Content-Encoding header is set to deflate.
+
+    Compression is skipped if it appears that compression ratio is
+    negative. Compression can be forced by repeating the argument.
+
+    '''
+)
+
+#######################################################################
+# Output processing
+#######################################################################
+
+output_processing = parser.add_argument_group(title='Output Processing')
+
+output_processing.add_argument(
+    '--pretty',
+    dest='prettify',
+    default=PRETTY_STDOUT_TTY_ONLY,
+    choices=sorted(PRETTY_MAP.keys()),
+    help='''
+    Controls output processing. The value can be "none" to not prettify
+    the output (default for redirected output), "all" to apply both colors
+    and formatting (default for terminal output), "colors", or "format".
+
+    '''
+)
+output_processing.add_argument(
+    '--style', '-s',
+    dest='style',
+    metavar='STYLE',
+    default=DEFAULT_STYLE,
+    choices=AVAILABLE_STYLES,
+    help='''
+    Output coloring style (default is "{default}"). It can be One of:
+
+    {available_styles}
+
+    The "{auto_style}" style follows your terminal's ANSI color styles.
+
+    For non-{auto_style} styles to work properly, please make sure that the
+    $TERM environment variable is set to "xterm-256color" or similar
+    (e.g., via `export TERM=xterm-256color' in your ~/.bashrc).
+
+    '''.format(
+        default=DEFAULT_STYLE,
+        available_styles='\n'.join(
+            '{0}{1}'.format(8 * ' ', line.strip())
+            for line in wrap(', '.join(sorted(AVAILABLE_STYLES)), 60)
+        ).strip(),
+        auto_style=AUTO_STYLE,
+    )
+)
+_sorted_kwargs = {
+    'action': 'append_const',
+    'const': SORTED_FORMAT_OPTIONS_STRING,
+    'dest': 'format_options'
+}
+_unsorted_kwargs = {
+    'action': 'append_const',
+    'const': UNSORTED_FORMAT_OPTIONS_STRING,
+    'dest': 'format_options'
+}
+# The closest approx. of the documented resetting to default via --no-<option>.
+# We hide them from the doc because they act only as low-level aliases here.
+output_processing.add_argument('--no-unsorted', **_sorted_kwargs, help=SUPPRESS)
+output_processing.add_argument('--no-sorted', **_unsorted_kwargs, help=SUPPRESS)
+
+output_processing.add_argument(
+    '--unsorted',
+    **_unsorted_kwargs,
+    help=f'''
+    Disables all sorting while formatting output. It is a shortcut for:
+
+        --format-options={UNSORTED_FORMAT_OPTIONS_STRING}
+
+    '''
+)
+output_processing.add_argument(
+    '--sorted',
+    **_sorted_kwargs,
+    help=f'''
+    Re-enables all sorting options while formatting output. It is a shortcut for:
+
+        --format-options={SORTED_FORMAT_OPTIONS_STRING}
+
+    '''
+)
+
+
+output_processing.add_argument(
+    '--format-options',
+    action='append',
+    help='''
+    Controls output formatting. Only relevant when formatting is enabled
+    through (explicit or implied) --pretty=all or --pretty=format.
+    The following are the default options:
+
+        {option_list}
+
+    You may use this option multiple times, as well as specify multiple
+    comma-separated options at the same time. For example, this modifies the
+    settings to disable the sorting of JSON keys, and sets the indent size to 2:
+
+        --format-options json.sort_keys:false,json.indent:2
+
+    This is something you will typically put into your config file.
+
+    '''.format(
+        option_list='\n'.join(
+            (8 * ' ') + option for option in DEFAULT_FORMAT_OPTIONS).strip()
+    )
+)
+
+#######################################################################
+# Output options
+#######################################################################
+output_options = parser.add_argument_group(title='Output Options')
+
+output_options.add_argument(
+    '--print', '-p',
+    dest='output_options',
+    metavar='WHAT',
+    help=f'''
+    String specifying what the output should contain:
+
+        '{OUT_REQ_HEAD}' request headers
+        '{OUT_REQ_BODY}' request body
+        '{OUT_RESP_HEAD}' response headers
+        '{OUT_RESP_BODY}' response body
+
+    The default behaviour is '{OUTPUT_OPTIONS_DEFAULT}' (i.e., the response
+    headers and body is printed), if standard output is not redirected.
+    If the output is piped to another program or to a file, then only the
+    response body is printed by default.
+
+    '''
+)
+output_options.add_argument(
+    '--headers', '-h',
+    dest='output_options',
+    action='store_const',
+    const=OUT_RESP_HEAD,
+    help=f'''
+    Print only the response headers. Shortcut for --print={OUT_RESP_HEAD}.
+
+    '''
+)
+output_options.add_argument(
+    '--body', '-b',
+    dest='output_options',
+    action='store_const',
+    const=OUT_RESP_BODY,
+    help=f'''
+    Print only the response body. Shortcut for --print={OUT_RESP_BODY}.
+
+    '''
+)
+
+output_options.add_argument(
+    '--verbose', '-v',
+    dest='verbose',
+    action='store_true',
+    help='''
+    Verbose output. Print the whole request as well as the response. Also print
+    any intermediary requests/responses (such as redirects).
+    It's a shortcut for: --all --print={0}
+
+    '''.format(''.join(OUTPUT_OPTIONS))
+)
+output_options.add_argument(
+    '--all',
+    default=False,
+    action='store_true',
+    help='''
+    By default, only the final request/response is shown. Use this flag to show
+    any intermediary requests/responses as well. Intermediary requests include
+    followed redirects (with --follow), the first unauthorized request when
+    Digest auth is used (--auth=digest), etc.
+
+    '''
+)
+output_options.add_argument(
+    '--history-print', '-P',
+    dest='output_options_history',
+    metavar='WHAT',
+    help='''
+    The same as --print, -p but applies only to intermediary requests/responses
+    (such as redirects) when their inclusion is enabled with --all. If this
+    options is not specified, then they are formatted the same way as the final
+    response.
+
+    '''
+)
+output_options.add_argument(
+    '--stream', '-S',
+    action='store_true',
+    default=False,
+    help='''
+    Always stream the response body by line, i.e., behave like `tail -f'.
+
+    Without --stream and with --pretty (either set or implied),
+    HTTPie fetches the whole response before it outputs the processed data.
+
+    Set this option when you want to continuously display a prettified
+    long-lived response, such as one from the Twitter streaming API.
+
+    It is useful also without --pretty: It ensures that the output is flushed
+    more often and in smaller chunks.
+
+    '''
+)
+output_options.add_argument(
+    '--output', '-o',
+    type=FileType('a+b'),
+    dest='output_file',
+    metavar='FILE',
+    help='''
+    Save output to FILE instead of stdout. If --download is also set, then only
+    the response body is saved to FILE. Other parts of the HTTP exchange are
+    printed to stderr.
+
+    '''
+
+)
+
+output_options.add_argument(
+    '--download', '-d',
+    action='store_true',
+    default=False,
+    help='''
+    Do not print the response body to stdout. Rather, download it and store it
+    in a file. The filename is guessed unless specified with --output
+    [filename]. This action is similar to the default behaviour of wget.
+
+    '''
+)
+
+output_options.add_argument(
+    '--continue', '-c',
+    dest='download_resume',
+    action='store_true',
+    default=False,
+    help='''
+    Resume an interrupted download. Note that the --output option needs to be
+    specified as well.
+
+    '''
+)
+
+output_options.add_argument(
+    '--quiet', '-q',
+    action='store_true',
+    default=False,
+    help='''
+    Do not print to stdout or stderr.
+    stdout is still redirected if --output is specified.
+    Flag doesn't affect behaviour of download beyond not printing to terminal.
+    '''
+)
+
+#######################################################################
+# Sessions
+#######################################################################
+
+sessions = parser.add_argument_group(title='Sessions') \
+    .add_mutually_exclusive_group(required=False)
+
+session_name_validator = SessionNameValidator(
+    'Session name contains invalid characters.'
+)
+
+sessions.add_argument(
+    '--session',
+    metavar='SESSION_NAME_OR_PATH',
+    type=session_name_validator,
+    help=f'''
+    Create, or reuse and update a session. Within a session, custom headers,
+    auth credential, as well as any cookies sent by the server persist between
+    requests.
+
+    Session files are stored in:
+
+        {DEFAULT_SESSIONS_DIR}/<HOST>/<SESSION_NAME>.json.
+
+    '''
+)
+sessions.add_argument(
+    '--session-read-only',
+    metavar='SESSION_NAME_OR_PATH',
+    type=session_name_validator,
+    help='''
+    Create or read a session without updating it form the request/response
+    exchange.
+
+    '''
+)
+
+#######################################################################
+# Authentication
+#######################################################################
+
+# ``requests.request`` keyword arguments.
+auth = parser.add_argument_group(title='Authentication')
+auth.add_argument(
+    '--auth', '-a',
+    default=None,
+    metavar='USER[:PASS]',
+    help='''
+    If only the username is provided (-a username), HTTPie will prompt
+    for the password.
+
+    ''',
+)
+
+
+class _AuthTypeLazyChoices:
+    # Needed for plugin testing
+
+    def __contains__(self, item):
+        return item in plugin_manager.get_auth_plugin_mapping()
+
+    def __iter__(self):
+        return iter(sorted(plugin_manager.get_auth_plugin_mapping().keys()))
+
+
+_auth_plugins = plugin_manager.get_auth_plugins()
+auth.add_argument(
+    '--auth-type', '-A',
+    choices=_AuthTypeLazyChoices(),
+    default=None,
+    help='''
+    The authentication mechanism to be used. Defaults to "{default}".
+
+    {types}
+
+    '''.format(default=_auth_plugins[0].auth_type, types='\n    '.join(
+        '"{type}": {name}{package}{description}'.format(
+            type=plugin.auth_type,
+            name=plugin.name,
+            package=(
+                '' if issubclass(plugin, BuiltinAuthPlugin)
+                else ' (provided by %s)' % plugin.package_name
+            ),
+            description=(
+                '' if not plugin.description else
+                '\n      ' + ('\n      '.join(wrap(plugin.description)))
+            )
+        )
+        for plugin in _auth_plugins
+    )),
+)
+auth.add_argument(
+    '--ignore-netrc',
+    default=False,
+    action='store_true',
+    help='''
+    Ignore credentials from .netrc.
+
+    ''',
+)
+
+#######################################################################
+# Network
+#######################################################################
+
+network = parser.add_argument_group(title='Network')
+
+network.add_argument(
+    '--offline',
+    default=False,
+    action='store_true',
+    help='''
+    Build the request and print it but don’t actually send it.
+    '''
+)
+network.add_argument(
+    '--proxy',
+    default=[],
+    action='append',
+    metavar='PROTOCOL:PROXY_URL',
+    type=KeyValueArgType(SEPARATOR_PROXY),
+    help='''
+    String mapping protocol to the URL of the proxy
+    (e.g. http:http://foo.bar:3128). You can specify multiple proxies with
+    different protocols. The environment variables $ALL_PROXY, $HTTP_PROXY,
+    and $HTTPS_proxy are supported as well.
+
+    '''
+)
+network.add_argument(
+    '--follow', '-F',
+    default=False,
+    action='store_true',
+    help='''
+    Follow 30x Location redirects.
+
+    '''
+)
+
+network.add_argument(
+    '--max-redirects',
+    type=int,
+    default=30,
+    help='''
+    By default, requests have a limit of 30 redirects (works with --follow).
+
+    '''
+)
+
+network.add_argument(
+    '--max-headers',
+    type=int,
+    default=0,
+    help='''
+    The maximum number of response headers to be read before giving up
+    (default 0, i.e., no limit).
+
+    '''
+)
+
+network.add_argument(
+    '--timeout',
+    type=float,
+    default=0,
+    metavar='SECONDS',
+    help='''
+    The connection timeout of the request in seconds.
+    The default value is 0, i.e., there is no timeout limit.
+    This is not a time limit on the entire response download;
+    rather, an error is reported if the server has not issued a response for
+    timeout seconds (more precisely, if no bytes have been received on
+    the underlying socket for timeout seconds).
+
+    '''
+)
+network.add_argument(
+    '--check-status',
+    default=False,
+    action='store_true',
+    help='''
+    By default, HTTPie exits with 0 when no network or other fatal errors
+    occur. This flag instructs HTTPie to also check the HTTP status code and
+    exit with an error if the status indicates one.
+
+    When the server replies with a 4xx (Client Error) or 5xx (Server Error)
+    status code, HTTPie exits with 4 or 5 respectively. If the response is a
+    3xx (Redirect) and --follow hasn't been set, then the exit status is 3.
+    Also an error message is written to stderr if stdout is redirected.
+
+    '''
+)
+network.add_argument(
+    '--path-as-is',
+    default=False,
+    action='store_true',
+    help='''
+    Bypass dot segment (/../ or /./) URL squashing.
+
+    '''
+)
+
+network.add_argument(
+    '--chunked',
+    default=False,
+    action='store_true',
+    help="""
+
+    """
+)
+
+#######################################################################
+# SSL
+#######################################################################
+
+ssl = parser.add_argument_group(title='SSL')
+ssl.add_argument(
+    '--verify',
+    default='yes',
+    help='''
+    Set to "no" (or "false") to skip checking the host's SSL certificate.
+    Defaults to "yes" ("true"). You can also pass the path to a CA_BUNDLE file
+    for private certs. (Or you can set the REQUESTS_CA_BUNDLE environment
+    variable instead.)
+    '''
+)
+ssl.add_argument(
+    '--ssl',
+    dest='ssl_version',
+    choices=list(sorted(AVAILABLE_SSL_VERSION_ARG_MAPPING.keys())),
+    help='''
+    The desired protocol version to use. This will default to
+    SSL v2.3 which will negotiate the highest protocol that both
+    the server and your installation of OpenSSL support. Available protocols
+    may vary depending on OpenSSL installation (only the supported ones
+    are shown here).
+
+    '''
+)
+ssl.add_argument(
+    '--ciphers',
+    help=f'''
+
+    A string in the OpenSSL cipher list format. By default, the following
+    is used:
+
+    {DEFAULT_SSL_CIPHERS}
+
+    '''
+)
+ssl.add_argument(
+    '--cert',
+    default=None,
+    type=readable_file_arg,
+    help='''
+    You can specify a local cert to use as client side SSL certificate.
+    This file may either contain both private key and certificate or you may
+    specify --cert-key separately.
+
+    '''
+)
+
+ssl.add_argument(
+    '--cert-key',
+    default=None,
+    type=readable_file_arg,
+    help='''
+    The private key to use with SSL. Only needed if --cert is given and the
+    certificate file does not contain the private key.
+
+    '''
+)
+
+#######################################################################
+# Troubleshooting
+#######################################################################
+
+troubleshooting = parser.add_argument_group(title='Troubleshooting')
+
+troubleshooting.add_argument(
+    '--ignore-stdin', '-I',
+    action='store_true',
+    default=False,
+    help='''
+    Do not attempt to read stdin.
+
+    '''
+)
+troubleshooting.add_argument(
+    '--help',
+    action='help',
+    default=SUPPRESS,
+    help='''
+    Show this help message and exit.
+
+    '''
+)
+troubleshooting.add_argument(
+    '--version',
+    action='version',
+    version=__version__,
+    help='''
+    Show version and exit.
+
+    '''
+)
+troubleshooting.add_argument(
+    '--traceback',
+    action='store_true',
+    default=False,
+    help='''
+    Prints the exception traceback should one occur.
+
+    '''
+)
+troubleshooting.add_argument(
+    '--default-scheme',
+    default="http",
+    help='''
+    The default scheme to use if not specified in the URL.
+
+    '''
+)
+troubleshooting.add_argument(
+    '--debug',
+    action='store_true',
+    default=False,
+    help='''
+    Prints the exception traceback should one occur, as well as other
+    information useful for debugging HTTPie itself and for reporting bugs.
+
+    '''
+)

httpie/cli/dicts.py

@@ -0,0 +1,58 @@
+from collections import OrderedDict
+
+from requests.structures import CaseInsensitiveDict
+
+
+class RequestHeadersDict(CaseInsensitiveDict):
+    """
+    Headers are case-insensitive and multiple values are currently not supported.
+
+    """
+
+
+class RequestJSONDataDict(OrderedDict):
+    pass
+
+
+class MultiValueOrderedDict(OrderedDict):
+    """Multi-value dict for URL parameters and form data."""
+
+    def __setitem__(self, key, value):
+        """
+        If `key` is assigned more than once, `self[key]` holds a
+        `list` of all the values.
+
+        This allows having multiple fields with the same name in form
+        data and URL params.
+
+        """
+        assert not isinstance(value, list)
+        if key not in self:
+            super().__setitem__(key, value)
+        else:
+            if not isinstance(self[key], list):
+                super().__setitem__(key, [self[key]])
+            self[key].append(value)
+
+    def items(self):
+        for key, values in super().items():
+            if not isinstance(values, list):
+                values = [values]
+            for value in values:
+                yield key, value
+
+
+class RequestQueryParamsDict(MultiValueOrderedDict):
+    pass
+
+
+class RequestDataDict(MultiValueOrderedDict):
+    pass
+
+
+class MultipartRequestDataDict(MultiValueOrderedDict):
+    pass
+
+
+class RequestFilesDict(RequestDataDict):
+    pass

httpie/cli/exceptions.py

@@ -0,0 +1,2 @@
+class ParseError(Exception):
+    pass

httpie/cli/requestitems.py

@@ -0,0 +1,159 @@
+import os
+from io import BytesIO
+from typing import Callable, Dict, IO, List, Optional, Tuple, Union
+
+from httpie.cli.argtypes import KeyValueArg
+from httpie.cli.constants import (
+    SEPARATORS_GROUP_MULTIPART, SEPARATOR_DATA_EMBED_FILE_CONTENTS,
+    SEPARATOR_DATA_EMBED_RAW_JSON_FILE,
+    SEPARATOR_DATA_RAW_JSON, SEPARATOR_DATA_STRING, SEPARATOR_FILE_UPLOAD,
+    SEPARATOR_FILE_UPLOAD_TYPE, SEPARATOR_HEADER, SEPARATOR_HEADER_EMPTY,
+    SEPARATOR_QUERY_PARAM,
+)
+from httpie.cli.dicts import (
+    MultipartRequestDataDict, RequestDataDict, RequestFilesDict,
+    RequestHeadersDict, RequestJSONDataDict,
+    RequestQueryParamsDict,
+)
+from httpie.cli.exceptions import ParseError
+from httpie.utils import (get_content_type, load_json_preserve_order)
+
+
+class RequestItems:
+
+    def __init__(self, as_form=False):
+        self.headers = RequestHeadersDict()
+        self.data = RequestDataDict() if as_form else RequestJSONDataDict()
+        self.files = RequestFilesDict()
+        self.params = RequestQueryParamsDict()
+        # To preserve the order of fields in file upload multipart requests.
+        self.multipart_data = MultipartRequestDataDict()
+
+    @classmethod
+    def from_args(
+        cls,
+        request_item_args: List[KeyValueArg],
+        as_form=False,
+    ) -> 'RequestItems':
+        instance = cls(as_form=as_form)
+        rules: Dict[str, Tuple[Callable, dict]] = {
+            SEPARATOR_HEADER: (
+                process_header_arg,
+                instance.headers,
+            ),
+            SEPARATOR_HEADER_EMPTY: (
+                process_empty_header_arg,
+                instance.headers,
+            ),
+            SEPARATOR_QUERY_PARAM: (
+                process_query_param_arg,
+                instance.params,
+            ),
+            SEPARATOR_FILE_UPLOAD: (
+                process_file_upload_arg,
+                instance.files,
+            ),
+            SEPARATOR_DATA_STRING: (
+                process_data_item_arg,
+                instance.data,
+            ),
+            SEPARATOR_DATA_EMBED_FILE_CONTENTS: (
+                process_data_embed_file_contents_arg,
+                instance.data,
+            ),
+            SEPARATOR_DATA_RAW_JSON: (
+                process_data_raw_json_embed_arg,
+                instance.data,
+            ),
+            SEPARATOR_DATA_EMBED_RAW_JSON_FILE: (
+                process_data_embed_raw_json_file_arg,
+                instance.data,
+            ),
+        }
+
+        for arg in request_item_args:
+            processor_func, target_dict = rules[arg.sep]
+            value = processor_func(arg)
+            target_dict[arg.key] = value
+
+            if arg.sep in SEPARATORS_GROUP_MULTIPART:
+                instance.multipart_data[arg.key] = value
+
+        return instance
+
+
+JSONType = Union[str, bool, int, list, dict]
+
+
+def process_header_arg(arg: KeyValueArg) -> Optional[str]:
+    return arg.value or None
+
+
+def process_empty_header_arg(arg: KeyValueArg) -> str:
+    if arg.value:
+        raise ParseError(
+            'Invalid item "%s" '
+            '(to specify an empty header use `Header;`)'
+            % arg.orig
+        )
+    return arg.value
+
+
+def process_query_param_arg(arg: KeyValueArg) -> str:
+    return arg.value
+
+
+def process_file_upload_arg(arg: KeyValueArg) -> Tuple[str, IO, str]:
+    parts = arg.value.split(SEPARATOR_FILE_UPLOAD_TYPE)
+    filename = parts[0]
+    mime_type = parts[1] if len(parts) > 1 else None
+    try:
+        f = open(os.path.expanduser(filename), 'rb')
+    except IOError as e:
+        raise ParseError('"%s": %s' % (arg.orig, e))
+    return (
+        os.path.basename(filename),
+        f,
+        mime_type or get_content_type(filename),
+    )
+
+
+def process_data_item_arg(arg: KeyValueArg) -> str:
+    return arg.value
+
+
+def process_data_embed_file_contents_arg(arg: KeyValueArg) -> str:
+    return load_text_file(arg)
+
+
+def process_data_embed_raw_json_file_arg(arg: KeyValueArg) -> JSONType:
+    contents = load_text_file(arg)
+    value = load_json(arg, contents)
+    return value
+
+
+def process_data_raw_json_embed_arg(arg: KeyValueArg) -> JSONType:
+    value = load_json(arg, arg.value)
+    return value
+
+
+def load_text_file(item: KeyValueArg) -> str:
+    path = item.value
+    try:
+        with open(os.path.expanduser(path), 'rb') as f:
+            return f.read().decode()
+    except IOError as e:
+        raise ParseError('"%s": %s' % (item.orig, e))
+    except UnicodeDecodeError:
+        raise ParseError(
+            '"%s": cannot embed the content of "%s",'
+            ' not a UTF8 or ASCII-encoded text file'
+            % (item.orig, item.value)
+        )
+
+
+def load_json(arg: KeyValueArg, contents: str) -> JSONType:
+    try:
+        return load_json_preserve_order(contents)
+    except ValueError as e:
+        raise ParseError('"%s": %s' % (arg.orig, e))

httpie/client.py

@@ -1,94 +1,324 @@
+import argparse
+import http.client
 import json
 import sys
-from pprint import pformat
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Callable, Iterable, Union
+from urllib.parse import urlparse, urlunparse
 
 import requests
-import requests.auth
-
-from . import sessions
-from . import __version__
+# noinspection PyPackageRequirements
+import urllib3
+from httpie import __version__
+from httpie.cli.dicts import RequestHeadersDict
+from httpie.plugins.registry import plugin_manager
+from httpie.sessions import get_httpie_session
+from httpie.ssl import AVAILABLE_SSL_VERSION_ARG_MAPPING, HTTPieHTTPSAdapter
+from httpie.uploads import (
+    compress_request, prepare_request_body,
+    get_multipart_data_and_content_type,
+)
+from httpie.utils import get_expired_cookies, repr_dict
 
 
-FORM = 'application/x-www-form-urlencoded; charset=utf-8'
-JSON = 'application/json; charset=utf-8'
-DEFAULT_UA = 'HTTPie/%s' % __version__
+urllib3.disable_warnings()
+
+FORM_CONTENT_TYPE = 'application/x-www-form-urlencoded; charset=utf-8'
+JSON_CONTENT_TYPE = 'application/json'
+JSON_ACCEPT = f'{JSON_CONTENT_TYPE}, */*;q=0.5'
+DEFAULT_UA = f'HTTPie/{__version__}'
 
 
-def get_response(args, config_dir):
-    """Send the request and return a `request.Response`."""
+def collect_messages(
+    args: argparse.Namespace,
+    config_dir: Path,
+    request_body_read_callback: Callable[[bytes], None] = None,
+) -> Iterable[Union[requests.PreparedRequest, requests.Response]]:
+    httpie_session = None
+    httpie_session_headers = None
+    if args.session or args.session_read_only:
+        httpie_session = get_httpie_session(
+            config_dir=config_dir,
+            session_name=args.session or args.session_read_only,
+            host=args.headers.get('Host'),
+            url=args.url,
+        )
+        httpie_session_headers = httpie_session.headers
 
-    requests_kwargs = get_requests_kwargs(args)
+    request_kwargs = make_request_kwargs(
+        args=args,
+        base_headers=httpie_session_headers,
+        request_body_read_callback=request_body_read_callback
+    )
+    send_kwargs = make_send_kwargs(args)
+    send_kwargs_mergeable_from_env = make_send_kwargs_mergeable_from_env(args)
+    requests_session = build_requests_session(
+        ssl_version=args.ssl_version,
+        ciphers=args.ciphers,
+        verify=bool(send_kwargs_mergeable_from_env['verify'])
+    )
+
+    if httpie_session:
+        httpie_session.update_headers(request_kwargs['headers'])
+        requests_session.cookies = httpie_session.cookies
+        if args.auth_plugin:
+            # Save auth from CLI to HTTPie session.
+            httpie_session.auth = {
+                'type': args.auth_plugin.auth_type,
+                'raw_auth': args.auth_plugin.raw_auth,
+            }
+        elif httpie_session.auth:
+            # Apply auth from HTTPie session
+            request_kwargs['auth'] = httpie_session.auth
 
     if args.debug:
-        sys.stderr.write('\n>>> requests.request(%s)\n\n'
-                         % pformat(requests_kwargs))
+        # TODO: reflect the split between request and send kwargs.
+        dump_request(request_kwargs)
 
-    if not args.session and not args.session_read_only:
-        response = requests.request(**requests_kwargs)
-    else:
-        response = sessions.get_response(
-            config_dir=config_dir,
-            name=args.session or args.session_read_only,
-            request_kwargs=requests_kwargs,
-            read_only=bool(args.session_read_only),
+    request = requests.Request(**request_kwargs)
+    prepared_request = requests_session.prepare_request(request)
+    if args.path_as_is:
+        prepared_request.url = ensure_path_as_is(
+            orig_url=args.url,
+            prepped_url=prepared_request.url,
+        )
+    if args.compress and prepared_request.body:
+        compress_request(
+            request=prepared_request,
+            always=args.compress > 1,
+        )
+    response_count = 0
+    expired_cookies = []
+    while prepared_request:
+        yield prepared_request
+        if not args.offline:
+            send_kwargs_merged = requests_session.merge_environment_settings(
+                url=prepared_request.url,
+                **send_kwargs_mergeable_from_env,
+            )
+            with max_headers(args.max_headers):
+                response = requests_session.send(
+                    request=prepared_request,
+                    **send_kwargs_merged,
+                    **send_kwargs,
+                )
+
+            # noinspection PyProtectedMember
+            expired_cookies += get_expired_cookies(
+                headers=response.raw._original_response.msg._headers
+            )
+
+            response_count += 1
+            if response.next:
+                if args.max_redirects and response_count == args.max_redirects:
+                    raise requests.TooManyRedirects
+                if args.follow:
+                    prepared_request = response.next
+                    if args.all:
+                        yield response
+                    continue
+            yield response
+        break
+
+    if httpie_session:
+        if httpie_session.is_new() or not args.session_read_only:
+            httpie_session.cookies = requests_session.cookies
+            httpie_session.remove_cookies(
+                # TODO: take path & domain into account?
+                cookie['name'] for cookie in expired_cookies
+            )
+            httpie_session.save()
+
+
+# noinspection PyProtectedMember
+@contextmanager
+def max_headers(limit):
+    # <https://github.com/jakubroztocil/httpie/issues/802>
+    # noinspection PyUnresolvedReferences
+    orig = http.client._MAXHEADERS
+    http.client._MAXHEADERS = limit or float('Inf')
+    try:
+        yield
+    finally:
+        http.client._MAXHEADERS = orig
+
+
+def build_requests_session(
+    verify: bool,
+    ssl_version: str = None,
+    ciphers: str = None,
+) -> requests.Session:
+    requests_session = requests.Session()
+
+    # Install our adapter.
+    https_adapter = HTTPieHTTPSAdapter(
+        ciphers=ciphers,
+        verify=verify,
+        ssl_version=(
+            AVAILABLE_SSL_VERSION_ARG_MAPPING[ssl_version]
+            if ssl_version else None
+        ),
+    )
+    requests_session.mount('https://', https_adapter)
+
+    # Install adapters from plugins.
+    for plugin_cls in plugin_manager.get_transport_plugins():
+        transport_plugin = plugin_cls()
+        requests_session.mount(
+            prefix=transport_plugin.prefix,
+            adapter=transport_plugin.get_adapter(),
         )
 
-    return response
+    return requests_session
 
 
-def get_requests_kwargs(args):
-    """Translate our `args` into `requests.request` keyword arguments."""
+def dump_request(kwargs: dict):
+    sys.stderr.write(
+        f'\n>>> requests.request(**{repr_dict(kwargs)})\n\n')
 
-    implicit_headers = {
+
+def finalize_headers(headers: RequestHeadersDict) -> RequestHeadersDict:
+    final_headers = RequestHeadersDict()
+    for name, value in headers.items():
+        if value is not None:
+            # “leading or trailing LWS MAY be removed without
+            # changing the semantics of the field value”
+            # <https://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html>
+            # Also, requests raises `InvalidHeader` for leading spaces.
+            value = value.strip()
+            if isinstance(value, str):
+                # See <https://github.com/jakubroztocil/httpie/issues/212>
+                value = value.encode('utf8')
+        final_headers[name] = value
+    return final_headers
+
+
+def make_default_headers(args: argparse.Namespace) -> RequestHeadersDict:
+    default_headers = RequestHeadersDict({
         'User-Agent': DEFAULT_UA
-    }
+    })
 
     auto_json = args.data and not args.form
     if args.json or auto_json:
-        implicit_headers['Accept'] = 'application/json'
-        if args.data:
-            implicit_headers['Content-Type'] = JSON
-
-        if isinstance(args.data, dict):
-            if args.data:
-                args.data = json.dumps(args.data)
-            else:
-                # We need to set data to an empty string to prevent requests
-                # from assigning an empty list to `response.request.data`.
-                args.data = ''
+        default_headers['Accept'] = JSON_ACCEPT
+        if args.json or (auto_json and args.data):
+            default_headers['Content-Type'] = JSON_CONTENT_TYPE
 
     elif args.form and not args.files:
         # If sending files, `requests` will set
         # the `Content-Type` for us.
-        implicit_headers['Content-Type'] = FORM
+        default_headers['Content-Type'] = FORM_CONTENT_TYPE
+    return default_headers
 
-    for name, value in implicit_headers.items():
-        if name not in args.headers:
-            args.headers[name] = value
-
-    credentials = None
-    if args.auth:
-        credentials = {
-            'basic': requests.auth.HTTPBasicAuth,
-            'digest': requests.auth.HTTPDigestAuth,
-        }[args.auth_type](args.auth.key, args.auth.value)
 
+def make_send_kwargs(args: argparse.Namespace) -> dict:
     kwargs = {
+        'timeout': args.timeout or None,
+        'allow_redirects': False,
+    }
+    return kwargs
+
+
+def make_send_kwargs_mergeable_from_env(args: argparse.Namespace) -> dict:
+    cert = None
+    if args.cert:
+        cert = args.cert
+        if args.cert_key:
+            cert = cert, args.cert_key
+    kwargs = {
+        'proxies': {p.key: p.value for p in args.proxy},
         'stream': True,
-        'method': args.method.lower(),
-        'url': args.url,
-        'headers': args.headers,
-        'data': args.data,
         'verify': {
             'yes': True,
-            'no': False
-        }.get(args.verify, args.verify),
-        'timeout': args.timeout,
-        'auth': credentials,
-        'proxies': dict((p.key, p.value) for p in args.proxy),
-        'files': args.files,
-        'allow_redirects': args.follow,
-        'params': args.params,
+            'true': True,
+            'no': False,
+            'false': False,
+        }.get(args.verify.lower(), args.verify),
+        'cert': cert,
+    }
+    return kwargs
+
+
+def make_request_kwargs(
+    args: argparse.Namespace,
+    base_headers: RequestHeadersDict = None,
+    request_body_read_callback=lambda chunk: chunk
+) -> dict:
+    """
+    Translate our `args` into `requests.Request` keyword arguments.
+
+    """
+    files = args.files
+    # Serialize JSON data, if needed.
+    data = args.data
+    auto_json = data and not args.form
+    if (args.json or auto_json) and isinstance(data, dict):
+        if data:
+            data = json.dumps(data)
+        else:
+            # We need to set data to an empty string to prevent requests
+            # from assigning an empty list to `response.request.data`.
+            data = ''
+
+    # Finalize headers.
+    headers = make_default_headers(args)
+    if base_headers:
+        headers.update(base_headers)
+    headers.update(args.headers)
+    if args.offline and args.chunked and 'Transfer-Encoding' not in headers:
+        # When online, we let requests set the header instead to be able more
+        # easily verify chunking is taking place.
+        headers['Transfer-Encoding'] = 'chunked'
+    headers = finalize_headers(headers)
+
+    if (args.form and files) or args.multipart:
+        data, headers['Content-Type'] = get_multipart_data_and_content_type(
+            data=args.multipart_data,
+            boundary=args.boundary,
+            content_type=args.headers.get('Content-Type'),
+        )
+
+    kwargs = {
+        'method': args.method.lower(),
+        'url': args.url,
+        'headers': headers,
+        'data': prepare_request_body(
+            body=data,
+            body_read_callback=request_body_read_callback,
+            chunked=args.chunked,
+            offline=args.offline,
+            content_length_header_value=headers.get('Content-Length'),
+        ),
+        'auth': args.auth,
+        'params': args.params.items(),
     }
 
     return kwargs
+
+
+def ensure_path_as_is(orig_url: str, prepped_url: str) -> str:
+    """
+    Handle `--path-as-is` by replacing the path component of the prepared
+    URL with the path component from the original URL. Other parts stay
+    untouched because other (welcome) processing on the URL might have
+    taken place.
+
+    <https://github.com/jakubroztocil/httpie/issues/895>
+
+
+    <https://ec.haxx.se/http/http-basics#path-as-is>
+    <https://curl.haxx.se/libcurl/c/CURLOPT_PATH_AS_IS.html>
+
+    >>> ensure_path_as_is('http://foo/../', 'http://foo/?foo=bar')
+    'http://foo/../?foo=bar'
+
+    """
+    parsed_orig, parsed_prepped = urlparse(orig_url), urlparse(prepped_url)
+    final_dict = {
+        # noinspection PyProtectedMember
+        **parsed_prepped._asdict(),
+        'path': parsed_orig.path,
+    }
+    final_url = urlunparse(tuple(final_dict.values()))
+    return final_url

httpie/compat.py

@@ -1,18 +1,4 @@
-"""
-Python 2/3 compatibility.
+import sys
 
-"""
-#noinspection PyUnresolvedReferences
-from requests.compat import (
-    is_windows,
-    bytes,
-    str,
-    is_py3,
-    is_py26,
-)
-
-try:
-    from urllib.parse import urlsplit
-except ImportError:
-    from urlparse import urlsplit
 
+is_windows = 'win32' in str(sys.platform).lower()

httpie/config.py

@@ -1,95 +1,144 @@
-import os
-import json
 import errno
+import json
+import os
+from pathlib import Path
+from typing import Union
 
-from . import __version__
-from .compat import is_windows
+from httpie import __version__
+from httpie.compat import is_windows
 
 
-DEFAULT_CONFIG_DIR = os.environ.get(
-    'HTTPIE_CONFIG_DIR',
-    os.path.expanduser('~/.httpie') if not is_windows else
-    os.path.expandvars(r'%APPDATA%\\httpie')
-)
+ENV_XDG_CONFIG_HOME = 'XDG_CONFIG_HOME'
+ENV_HTTPIE_CONFIG_DIR = 'HTTPIE_CONFIG_DIR'
+DEFAULT_CONFIG_DIRNAME = 'httpie'
+DEFAULT_RELATIVE_XDG_CONFIG_HOME = Path('.config')
+DEFAULT_RELATIVE_LEGACY_CONFIG_DIR = Path('.httpie')
+DEFAULT_WINDOWS_CONFIG_DIR = Path(
+    os.path.expandvars('%APPDATA%')) / DEFAULT_CONFIG_DIRNAME
+
+
+def get_default_config_dir() -> Path:
+    """
+    Return the path to the httpie configuration directory.
+
+    This directory isn't guaranteed to exist, and nor are any of its
+    ancestors (only the legacy ~/.httpie, if returned, is guaranteed to exist).
+
+    XDG Base Directory Specification support:
+
+        <https://wiki.archlinux.org/index.php/XDG_Base_Directory>
+
+        $XDG_CONFIG_HOME is supported; $XDG_CONFIG_DIRS is not
+
+    """
+    # 1. explicitly set through env
+    env_config_dir = os.environ.get(ENV_HTTPIE_CONFIG_DIR)
+    if env_config_dir:
+        return Path(env_config_dir)
+
+    # 2. Windows
+    if is_windows:
+        return DEFAULT_WINDOWS_CONFIG_DIR
+
+    home_dir = Path.home()
+
+    # 3. legacy ~/.httpie
+    legacy_config_dir = home_dir / DEFAULT_RELATIVE_LEGACY_CONFIG_DIR
+    if legacy_config_dir.exists():
+        return legacy_config_dir
+
+    # 4. XDG
+    xdg_config_home_dir = os.environ.get(
+        ENV_XDG_CONFIG_HOME,  # 4.1. explicit
+        home_dir / DEFAULT_RELATIVE_XDG_CONFIG_HOME  # 4.2. default
+    )
+    return Path(xdg_config_home_dir) / DEFAULT_CONFIG_DIRNAME
+
+
+DEFAULT_CONFIG_DIR = get_default_config_dir()
+
+
+class ConfigFileError(Exception):
+    pass
 
 
 class BaseConfigDict(dict):
-
     name = None
-    help = None
+    helpurl = None
     about = None
 
-    directory = DEFAULT_CONFIG_DIR
+    def __init__(self, path: Path):
+        super().__init__()
+        self.path = path
 
-    def __init__(self, directory=None, *args, **kwargs):
-        super(BaseConfigDict, self).__init__(*args, **kwargs)
-        if directory:
-            self.directory = directory
-
-    def __getattr__(self, item):
-        return self[item]
-
-    @property
-    def path(self):
+    def ensure_directory(self):
         try:
-            os.makedirs(self.directory, mode=0o700)
+            self.path.parent.mkdir(mode=0o700, parents=True)
         except OSError as e:
             if e.errno != errno.EEXIST:
                 raise
-        return os.path.join(self.directory, self.name + '.json')
 
-    @property
-    def is_new(self):
-        return not os.path.exists(self.path)
+    def is_new(self) -> bool:
+        return not self.path.exists()
 
     def load(self):
+        config_type = type(self).__name__.lower()
         try:
-            with open(self.path, 'rt') as f:
+            with self.path.open('rt') as f:
                 try:
                     data = json.load(f)
                 except ValueError as e:
-                    raise ValueError(
-                        'Invalid %s JSON: %s [%s]' %
-                        (type(self).__name__, e.message, self.path)
+                    raise ConfigFileError(
+                        f'invalid {config_type} file: {e} [{self.path}]'
                     )
                 self.update(data)
         except IOError as e:
             if e.errno != errno.ENOENT:
-                raise
+                raise ConfigFileError(f'cannot read {config_type} file: {e}')
 
-    def save(self):
+    def save(self, fail_silently=False):
         self['__meta__'] = {
             'httpie': __version__
         }
-        if self.help:
-            self['__meta__']['help'] = self.help
+        if self.helpurl:
+            self['__meta__']['help'] = self.helpurl
 
         if self.about:
             self['__meta__']['about'] = self.about
 
-        with open(self.path, 'w') as f:
-            json.dump(self, f, indent=4, sort_keys=True, ensure_ascii=True)
-            f.write('\n')
+        self.ensure_directory()
+
+        json_string = json.dumps(
+            obj=self,
+            indent=4,
+            sort_keys=True,
+            ensure_ascii=True,
+        )
+        try:
+            self.path.write_text(json_string + '\n')
+        except IOError:
+            if not fail_silently:
+                raise
 
     def delete(self):
         try:
-            os.unlink(self.path)
+            self.path.unlink()
         except OSError as e:
             if e.errno != errno.ENOENT:
                 raise
 
 
 class Config(BaseConfigDict):
-
-    name = 'config'
-    help = 'https://github.com/jkbr/httpie#config'
-    about = 'HTTPie configuration file'
-
+    FILENAME = 'config.json'
     DEFAULTS = {
-        'implicit_content_type': 'json',
         'default_options': []
     }
 
-    def __init__(self, *args, **kwargs):
-        super(Config, self).__init__(*args, **kwargs)
+    def __init__(self, directory: Union[str, Path] = DEFAULT_CONFIG_DIR):
+        self.directory = Path(directory)
+        super().__init__(path=self.directory / self.FILENAME)
         self.update(self.DEFAULTS)
+
+    @property
+    def default_options(self) -> list:
+        return self['default_options']

httpie/context.py

@@ -0,0 +1,128 @@
+import sys
+import os
+from pathlib import Path
+from typing import IO, Optional
+
+
+try:
+    import curses
+except ImportError:
+    curses = None  # Compiled w/o curses
+
+from httpie.compat import is_windows
+from httpie.config import DEFAULT_CONFIG_DIR, Config, ConfigFileError
+
+from httpie.utils import repr_dict
+
+
+class Environment:
+    """
+    Information about the execution context
+    (standard streams, config directory, etc).
+
+    By default, it represents the actual environment.
+    All of the attributes can be overwritten though, which
+    is used by the test suite to simulate various scenarios.
+
+    """
+    is_windows: bool = is_windows
+    config_dir: Path = DEFAULT_CONFIG_DIR
+    stdin: Optional[IO] = sys.stdin  # `None` when closed fd (#791)
+    stdin_isatty: bool = stdin.isatty() if stdin else False
+    stdin_encoding: str = None
+    stdout: IO = sys.stdout
+    stdout_isatty: bool = stdout.isatty()
+    stdout_encoding: str = None
+    stderr: IO = sys.stderr
+    stderr_isatty: bool = stderr.isatty()
+    colors = 256
+    program_name: str = 'http'
+    if not is_windows:
+        if curses:
+            try:
+                curses.setupterm()
+                colors = curses.tigetnum('colors')
+            except curses.error:
+                pass
+    else:
+        # noinspection PyUnresolvedReferences
+        import colorama.initialise
+        stdout = colorama.initialise.wrap_stream(
+            stdout, convert=None, strip=None,
+            autoreset=True, wrap=True
+        )
+        stderr = colorama.initialise.wrap_stream(
+            stderr, convert=None, strip=None,
+            autoreset=True, wrap=True
+        )
+        del colorama
+
+    def __init__(self, devnull=None, **kwargs):
+        """
+        Use keyword arguments to overwrite
+        any of the class attributes for this instance.
+
+        """
+        assert all(hasattr(type(self), attr) for attr in kwargs.keys())
+        self.__dict__.update(**kwargs)
+
+        # The original STDERR unaffected by --quiet’ing.
+        self._orig_stderr = self.stderr
+        self._devnull = devnull
+
+        # Keyword arguments > stream.encoding > default utf8
+        if self.stdin and self.stdin_encoding is None:
+            self.stdin_encoding = getattr(
+                self.stdin, 'encoding', None) or 'utf8'
+        if self.stdout_encoding is None:
+            actual_stdout = self.stdout
+            if is_windows:
+                # noinspection PyUnresolvedReferences
+                from colorama import AnsiToWin32
+                if isinstance(self.stdout, AnsiToWin32):
+                    # noinspection PyUnresolvedReferences
+                    actual_stdout = self.stdout.wrapped
+            self.stdout_encoding = getattr(
+                actual_stdout, 'encoding', None) or 'utf8'
+
+    def __str__(self):
+        defaults = dict(type(self).__dict__)
+        actual = dict(defaults)
+        actual.update(self.__dict__)
+        actual['config'] = self.config
+        return repr_dict({
+            key: value
+            for key, value in actual.items()
+            if not key.startswith('_')
+        })
+
+    def __repr__(self):
+        return f'<{type(self).__name__} {self}>'
+
+    _config: Config = None
+
+    @property
+    def config(self) -> Config:
+        config = self._config
+        if not config:
+            self._config = config = Config(directory=self.config_dir)
+            if not config.is_new():
+                try:
+                    config.load()
+                except ConfigFileError as e:
+                    self.log_error(e, level='warning')
+        return config
+
+    @property
+    def devnull(self) -> IO:
+        if self._devnull is None:
+            self._devnull = open(os.devnull, 'w+')
+        return self._devnull
+
+    @devnull.setter
+    def devnull(self, value):
+        self._devnull = value
+
+    def log_error(self, msg, level='error'):
+        assert level in ['error', 'warning']
+        self._orig_stderr.write(f'\n{self.program_name}: {level}: {msg}\n\n')

httpie/core.py

@@ -1,129 +1,288 @@
-"""This module provides the main functionality of HTTPie.
-
-Invocation flow:
-
-    1. Read, validate and process the input (args, `stdin`).
-    2. Create and send a request.
-    3. Stream, and possibly process and format, the requested parts
-       of the request-response exchange.
-    4. Simultaneously write to `stdout`
-    5. Exit.
-
-"""
+import argparse
+import os
+import platform
 import sys
-import errno
+from typing import List, Optional, Tuple, Union
 
 import requests
-from httpie import __version__ as httpie_version
-from requests import __version__ as requests_version
 from pygments import __version__ as pygments_version
+from requests import __version__ as requests_version
 
-from .cli import parser
-from .compat import str, is_py3
-from .client import get_response
-from .models import Environment
-from .output import build_output_stream, write, write_with_colors_win_p3k
-from . import ExitStatus
+from httpie import __version__ as httpie_version
+from httpie.cli.constants import (
+    OUT_REQ_BODY, OUT_REQ_HEAD, OUT_RESP_BODY,
+    OUT_RESP_HEAD,
+)
+from httpie.client import collect_messages
+from httpie.context import Environment
+from httpie.downloads import Downloader
+from httpie.output.writer import (
+    write_message,
+    write_stream,
+)
+from httpie.plugins.registry import plugin_manager
+from httpie.status import ExitStatus, http_status_to_exit_status
 
 
-def get_exit_status(http_status, follow=False):
-    """Translate HTTP status code to exit status code."""
-    if 300 <= http_status <= 399 and not follow:
-        # Redirect
-        return ExitStatus.ERROR_HTTP_3XX
-    elif 400 <= http_status <= 499:
-        # Client Error
-        return ExitStatus.ERROR_HTTP_4XX
-    elif 500 <= http_status <= 599:
-        # Server Error
-        return ExitStatus.ERROR_HTTP_5XX
-    else:
-        return ExitStatus.OK
+# noinspection PyDefaultArgument
+def main(
+    args: List[Union[str, bytes]] = sys.argv,
+    env=Environment(),
+) -> ExitStatus:
+    """
+    The main function.
 
-
-def print_debug_info(env):
-    sys.stderr.writelines([
-        'HTTPie %s\n' % httpie_version,
-        'HTTPie data: %s\n' % env.config.directory,
-        'Requests %s\n' % requests_version,
-        'Pygments %s\n' % pygments_version,
-        'Python %s %s\n' % (sys.version, sys.platform)
-    ])
-
-
-def main(args=sys.argv[1:], env=Environment()):
-    """Run the main program and write the output to ``env.stdout``.
+    Pre-process args, handle some special types of invocations,
+    and run the main program with error handling.
 
     Return exit status code.
 
     """
+    program_name, *args = args
+    env.program_name = os.path.basename(program_name)
+    args = decode_raw_args(args, env.stdin_encoding)
+    plugin_manager.load_installed_plugins()
+
+    from httpie.cli.definition import parser
+
     if env.config.default_options:
         args = env.config.default_options + args
 
-    def error(msg, *args, **kwargs):
-        msg = msg % args
-        level = kwargs.get('level', 'error')
-        env.stderr.write('http: %s: %s\n' % (level, msg))
+    include_debug_info = '--debug' in args
+    include_traceback = include_debug_info or '--traceback' in args
 
-    debug = '--debug' in args
-    traceback = debug or '--traceback' in args
-    exit_status = ExitStatus.OK
-
-    if debug:
+    if include_debug_info:
         print_debug_info(env)
         if args == ['--debug']:
-            return exit_status
+            return ExitStatus.SUCCESS
+
+    exit_status = ExitStatus.SUCCESS
 
     try:
-        args = parser.parse_args(args=args, env=env)
-
-        response = get_response(args, config_dir=env.config.directory)
-
-        if args.check_status:
-            exit_status = get_exit_status(response.status_code, args.follow)
-
-            if not env.stdout_isatty and exit_status != ExitStatus.OK:
-                error('HTTP %s %s',
-                      response.raw.status,
-                      response.raw.reason,
-                      level='warning')
-
-        write_kwargs = {
-            'stream': build_output_stream(args, env,
-                                          response.request,
-                                          response),
-            'outfile': env.stdout,
-            'flush': env.stdout_isatty or args.stream
-        }
-        try:
-            if env.is_windows and is_py3 and 'colors' in args.prettify:
-                write_with_colors_win_p3k(**write_kwargs)
-            else:
-                write(**write_kwargs)
-
-        except IOError as e:
-            if not traceback and e.errno == errno.EPIPE:
-                # Ignore broken pipes unless --traceback.
-                env.stderr.write('\n')
-            else:
-                raise
-
-    except (KeyboardInterrupt, SystemExit):
-        if traceback:
-            raise
+        parsed_args = parser.parse_args(
+            args=args,
+            env=env,
+        )
+    except KeyboardInterrupt:
         env.stderr.write('\n')
-        exit_status = ExitStatus.ERROR
-
-    except requests.Timeout:
-        exit_status = ExitStatus.ERROR_TIMEOUT
-        error('Request timed out (%ss).', args.timeout)
-
-    except Exception as e:
-        # TODO: Better distinction between expected and unexpected errors.
-        #       Network errors vs. bugs, etc.
-        if traceback:
+        if include_traceback:
             raise
-        error('%s: %s', type(e).__name__, str(e))
-        exit_status = ExitStatus.ERROR
+        exit_status = ExitStatus.ERROR_CTRL_C
+    except SystemExit as e:
+        if e.code != ExitStatus.SUCCESS:
+            env.stderr.write('\n')
+            if include_traceback:
+                raise
+            exit_status = ExitStatus.ERROR
+    else:
+        try:
+            exit_status = program(
+                args=parsed_args,
+                env=env,
+            )
+        except KeyboardInterrupt:
+            env.stderr.write('\n')
+            if include_traceback:
+                raise
+            exit_status = ExitStatus.ERROR_CTRL_C
+        except SystemExit as e:
+            if e.code != ExitStatus.SUCCESS:
+                env.stderr.write('\n')
+                if include_traceback:
+                    raise
+                exit_status = ExitStatus.ERROR
+        except requests.Timeout:
+            exit_status = ExitStatus.ERROR_TIMEOUT
+            env.log_error(f'Request timed out ({parsed_args.timeout}s).')
+        except requests.TooManyRedirects:
+            exit_status = ExitStatus.ERROR_TOO_MANY_REDIRECTS
+            env.log_error(
+                f'Too many redirects'
+                f' (--max-redirects={parsed_args.max_redirects}).'
+            )
+        except Exception as e:
+            # TODO: Further distinction between expected and unexpected errors.
+            msg = str(e)
+            if hasattr(e, 'request'):
+                request = e.request
+                if hasattr(request, 'url'):
+                    msg = (
+                        f'{msg} while doing a {request.method}'
+                        f' request to URL: {request.url}'
+                    )
+            env.log_error(f'{type(e).__name__}: {msg}')
+            if include_traceback:
+                raise
+            exit_status = ExitStatus.ERROR
 
     return exit_status
+
+
+def get_output_options(
+    args: argparse.Namespace,
+    message: Union[requests.PreparedRequest, requests.Response]
+) -> Tuple[bool, bool]:
+    return {
+        requests.PreparedRequest: (
+            OUT_REQ_HEAD in args.output_options,
+            OUT_REQ_BODY in args.output_options,
+        ),
+        requests.Response: (
+            OUT_RESP_HEAD in args.output_options,
+            OUT_RESP_BODY in args.output_options,
+        ),
+    }[type(message)]
+
+
+def program(
+    args: argparse.Namespace,
+    env: Environment,
+) -> ExitStatus:
+    """
+    The main program without error handling.
+
+    """
+    exit_status = ExitStatus.SUCCESS
+    downloader = None
+
+    try:
+        if args.download:
+            args.follow = True  # --download implies --follow.
+            downloader = Downloader(
+                output_file=args.output_file,
+                progress_file=env.stderr,
+                resume=args.download_resume
+            )
+            downloader.pre_request(args.headers)
+
+        needs_separator = False
+
+        def maybe_separate():
+            nonlocal needs_separator
+            if env.stdout.isatty() and needs_separator:
+                needs_separator = False
+                getattr(env.stdout, 'buffer', env.stdout).write(b'\n\n')
+
+        initial_request: Optional[requests.PreparedRequest] = None
+        final_response: Optional[requests.Response] = None
+
+        def request_body_read_callback(chunk: bytes):
+            should_pipe_to_stdout = (
+                # Request body output desired
+                OUT_REQ_BODY in args.output_options
+                # & not `.read()` already pre-request (e.g., for  compression)
+                and initial_request
+                # & non-EOF chunk
+                and chunk
+            )
+            if should_pipe_to_stdout:
+                msg = requests.PreparedRequest()
+                msg.is_body_upload_chunk = True
+                msg.body = chunk
+                msg.headers = initial_request.headers
+                write_message(
+                    requests_message=msg,
+                    env=env,
+                    args=args,
+                    with_body=True,
+                    with_headers=False
+                )
+
+        messages = collect_messages(
+            args=args,
+            config_dir=env.config.directory,
+            request_body_read_callback=request_body_read_callback
+        )
+        for message in messages:
+            maybe_separate()
+            is_request = isinstance(message, requests.PreparedRequest)
+            with_headers, with_body = get_output_options(
+                args=args, message=message)
+            if is_request:
+                if not initial_request:
+                    initial_request = message
+                    is_streamed_upload = not isinstance(
+                        message.body, (str, bytes))
+                    if with_body:
+                        with_body = not is_streamed_upload
+                        needs_separator = is_streamed_upload
+            else:
+                final_response = message
+                if args.check_status or downloader:
+                    exit_status = http_status_to_exit_status(
+                        http_status=message.status_code,
+                        follow=args.follow
+                    )
+                    if (not env.stdout_isatty
+                            and exit_status != ExitStatus.SUCCESS):
+                        env.log_error(
+                            f'HTTP {message.raw.status} {message.raw.reason}',
+                            level='warning'
+                        )
+            write_message(
+                requests_message=message,
+                env=env,
+                args=args,
+                with_headers=with_headers,
+                with_body=with_body,
+            )
+
+        maybe_separate()
+
+        if downloader and exit_status == ExitStatus.SUCCESS:
+            # Last response body download.
+            download_stream, download_to = downloader.start(
+                initial_url=initial_request.url,
+                final_response=final_response,
+            )
+            write_stream(
+                stream=download_stream,
+                outfile=download_to,
+                flush=False,
+            )
+            downloader.finish()
+            if downloader.interrupted:
+                exit_status = ExitStatus.ERROR
+                env.log_error(
+                    'Incomplete download: size=%d; downloaded=%d' % (
+                        downloader.status.total_size,
+                        downloader.status.downloaded
+                    ))
+        return exit_status
+
+    finally:
+        if downloader and not downloader.finished:
+            downloader.failed()
+
+        if (not isinstance(args, list) and args.output_file
+                and args.output_file_specified):
+            args.output_file.close()
+
+
+def print_debug_info(env: Environment):
+    env.stderr.writelines([
+        f'HTTPie {httpie_version}\n',
+        f'Requests {requests_version}\n',
+        f'Pygments {pygments_version}\n',
+        f'Python {sys.version}\n{sys.executable}\n',
+        f'{platform.system()} {platform.release()}',
+    ])
+    env.stderr.write('\n\n')
+    env.stderr.write(repr(env))
+    env.stderr.write('\n')
+
+
+def decode_raw_args(
+    args: List[Union[str, bytes]],
+    stdin_encoding: str
+) -> List[str]:
+    """
+    Convert all bytes args to str
+    by decoding them using stdin encoding.
+
+    """
+    return [
+        arg.decode(stdin_encoding)
+        if type(arg) == bytes else arg
+        for arg in args
+    ]

httpie/downloads.py

@@ -0,0 +1,492 @@
+# coding=utf-8
+"""
+Download mode implementation.
+
+"""
+from __future__ import division
+
+import errno
+import mimetypes
+import os
+import re
+import sys
+import threading
+from mailbox import Message
+from time import sleep, time
+from typing import IO, Optional, Tuple
+from urllib.parse import urlsplit
+
+import requests
+
+from httpie.models import HTTPResponse
+from httpie.output.streams import RawStream
+from httpie.utils import humanize_bytes
+
+
+PARTIAL_CONTENT = 206
+
+CLEAR_LINE = '\r\033[K'
+PROGRESS = (
+    '{percentage: 6.2f} %'
+    ' {downloaded: >10}'
+    ' {speed: >10}/s'
+    ' {eta: >8} ETA'
+)
+PROGRESS_NO_CONTENT_LENGTH = '{downloaded: >10} {speed: >10}/s'
+SUMMARY = 'Done. {downloaded} in {time:0.5f}s ({speed}/s)\n'
+SPINNER = '|/-\\'
+
+
+class ContentRangeError(ValueError):
+    pass
+
+
+def parse_content_range(content_range: str, resumed_from: int) -> int:
+    """
+    Parse and validate Content-Range header.
+
+    <https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html>
+
+    :param content_range: the value of a Content-Range response header
+                          eg. "bytes 21010-47021/47022"
+    :param resumed_from: first byte pos. from the Range request header
+    :return: total size of the response body when fully downloaded.
+
+    """
+    if content_range is None:
+        raise ContentRangeError('Missing Content-Range')
+
+    pattern = (
+        r'^bytes (?P<first_byte_pos>\d+)-(?P<last_byte_pos>\d+)'
+        r'/(\*|(?P<instance_length>\d+))$'
+    )
+    match = re.match(pattern, content_range)
+
+    if not match:
+        raise ContentRangeError(
+            'Invalid Content-Range format %r' % content_range)
+
+    content_range_dict = match.groupdict()
+    first_byte_pos = int(content_range_dict['first_byte_pos'])
+    last_byte_pos = int(content_range_dict['last_byte_pos'])
+    instance_length = (
+        int(content_range_dict['instance_length'])
+        if content_range_dict['instance_length']
+        else None
+    )
+
+    # "A byte-content-range-spec with a byte-range-resp-spec whose
+    # last- byte-pos value is less than its first-byte-pos value,
+    # or whose instance-length value is less than or equal to its
+    # last-byte-pos value, is invalid. The recipient of an invalid
+    # byte-content-range- spec MUST ignore it and any content
+    # transferred along with it."
+    if (first_byte_pos >= last_byte_pos
+        or (instance_length is not None
+            and instance_length <= last_byte_pos)):
+        raise ContentRangeError(
+            'Invalid Content-Range returned: %r' % content_range)
+
+    if (first_byte_pos != resumed_from
+        or (instance_length is not None
+            and last_byte_pos + 1 != instance_length)):
+        # Not what we asked for.
+        raise ContentRangeError(
+            'Unexpected Content-Range returned (%r)'
+            ' for the requested Range ("bytes=%d-")'
+            % (content_range, resumed_from)
+        )
+
+    return last_byte_pos + 1
+
+
+def filename_from_content_disposition(
+    content_disposition: str
+) -> Optional[str]:
+    """
+    Extract and validate filename from a Content-Disposition header.
+
+    :param content_disposition: Content-Disposition value
+    :return: the filename if present and valid, otherwise `None`
+
+    """
+    # attachment; filename=jakubroztocil-httpie-0.4.1-20-g40bd8f6.tar.gz
+
+    msg = Message('Content-Disposition: %s' % content_disposition)
+    filename = msg.get_filename()
+    if filename:
+        # Basic sanitation.
+        filename = os.path.basename(filename).lstrip('.').strip()
+        if filename:
+            return filename
+
+
+def filename_from_url(url: str, content_type: Optional[str]) -> str:
+    fn = urlsplit(url).path.rstrip('/')
+    fn = os.path.basename(fn) if fn else 'index'
+    if '.' not in fn and content_type:
+        content_type = content_type.split(';')[0]
+        if content_type == 'text/plain':
+            # mimetypes returns '.ksh'
+            ext = '.txt'
+        else:
+            ext = mimetypes.guess_extension(content_type)
+
+        if ext == '.htm':  # Python 3
+            ext = '.html'
+
+        if ext:
+            fn += ext
+
+    return fn
+
+
+def trim_filename(filename: str, max_len: int) -> str:
+    if len(filename) > max_len:
+        trim_by = len(filename) - max_len
+        name, ext = os.path.splitext(filename)
+        if trim_by >= len(name):
+            filename = filename[:-trim_by]
+        else:
+            filename = name[:-trim_by] + ext
+    return filename
+
+
+def get_filename_max_length(directory: str) -> int:
+    max_len = 255
+    try:
+        pathconf = os.pathconf
+    except AttributeError:
+        pass  # non-posix
+    else:
+        try:
+            max_len = pathconf(directory, 'PC_NAME_MAX')
+        except OSError as e:
+            if e.errno != errno.EINVAL:
+                raise
+    return max_len
+
+
+def trim_filename_if_needed(filename: str, directory='.', extra=0) -> str:
+    max_len = get_filename_max_length(directory) - extra
+    if len(filename) > max_len:
+        filename = trim_filename(filename, max_len)
+    return filename
+
+
+def get_unique_filename(filename: str, exists=os.path.exists) -> str:
+    attempt = 0
+    while True:
+        suffix = '-' + str(attempt) if attempt > 0 else ''
+        try_filename = trim_filename_if_needed(filename, extra=len(suffix))
+        try_filename += suffix
+        if not exists(try_filename):
+            return try_filename
+        attempt += 1
+
+
+class Downloader:
+
+    def __init__(
+        self,
+        output_file: IO = None,
+        resume: bool = False,
+        progress_file: IO = sys.stderr
+    ):
+        """
+        :param resume: Should the download resume if partial download
+                       already exists.
+
+        :param output_file: The file to store response body in. If not
+                            provided, it will be guessed from the response.
+
+        :param progress_file: Where to report download progress.
+
+        """
+        self.finished = False
+        self.status = DownloadStatus()
+        self._output_file = output_file
+        self._resume = resume
+        self._resumed_from = 0
+        self._progress_reporter = ProgressReporterThread(
+            status=self.status,
+            output=progress_file
+        )
+
+    def pre_request(self, request_headers: dict):
+        """Called just before the HTTP request is sent.
+
+        Might alter `request_headers`.
+
+        """
+        # Ask the server not to encode the content so that we can resume, etc.
+        request_headers['Accept-Encoding'] = 'identity'
+        if self._resume:
+            bytes_have = os.path.getsize(self._output_file.name)
+            if bytes_have:
+                # Set ``Range`` header to resume the download
+                # TODO: Use "If-Range: mtime" to make sure it's fresh?
+                request_headers['Range'] = 'bytes=%d-' % bytes_have
+                self._resumed_from = bytes_have
+
+    def start(
+        self,
+        initial_url: str,
+        final_response: requests.Response
+    ) -> Tuple[RawStream, IO]:
+        """
+        Initiate and return a stream for `response` body  with progress
+        callback attached. Can be called only once.
+
+        :param initial_url: The original requested URL
+        :param final_response: Initiated response object with headers already fetched
+
+        :return: RawStream, output_file
+
+        """
+        assert not self.status.time_started
+
+        # FIXME: some servers still might sent Content-Encoding: gzip
+        # <https://github.com/jakubroztocil/httpie/issues/423>
+        try:
+            total_size = int(final_response.headers['Content-Length'])
+        except (KeyError, ValueError, TypeError):
+            total_size = None
+
+        if not self._output_file:
+            self._output_file = self._get_output_file_from_response(
+                initial_url=initial_url,
+                final_response=final_response,
+            )
+        else:
+            # `--output, -o` provided
+            if self._resume and final_response.status_code == PARTIAL_CONTENT:
+                total_size = parse_content_range(
+                    final_response.headers.get('Content-Range'),
+                    self._resumed_from
+                )
+
+            else:
+                self._resumed_from = 0
+                try:
+                    self._output_file.seek(0)
+                    self._output_file.truncate()
+                except IOError:
+                    pass  # stdout
+
+        self.status.started(
+            resumed_from=self._resumed_from,
+            total_size=total_size
+        )
+
+        stream = RawStream(
+            msg=HTTPResponse(final_response),
+            with_headers=False,
+            with_body=True,
+            on_body_chunk_downloaded=self.chunk_downloaded,
+            chunk_size=1024 * 8
+        )
+
+        self._progress_reporter.output.write(
+            'Downloading %sto "%s"\n' % (
+                (humanize_bytes(total_size) + ' '
+                 if total_size is not None
+                 else ''),
+                self._output_file.name
+            )
+        )
+        self._progress_reporter.start()
+
+        return stream, self._output_file
+
+    def finish(self):
+        assert not self.finished
+        self.finished = True
+        self.status.finished()
+
+    def failed(self):
+        self._progress_reporter.stop()
+
+    @property
+    def interrupted(self) -> bool:
+        return (
+            self.finished
+            and self.status.total_size
+            and self.status.total_size != self.status.downloaded
+        )
+
+    def chunk_downloaded(self, chunk: bytes):
+        """
+        A download progress callback.
+
+        :param chunk: A chunk of response body data that has just
+                      been downloaded and written to the output.
+
+        """
+        self.status.chunk_downloaded(len(chunk))
+
+    @staticmethod
+    def _get_output_file_from_response(
+        initial_url: str,
+        final_response: requests.Response,
+    ) -> IO:
+        # Output file not specified. Pick a name that doesn't exist yet.
+        filename = None
+        if 'Content-Disposition' in final_response.headers:
+            filename = filename_from_content_disposition(
+                final_response.headers['Content-Disposition'])
+        if not filename:
+            filename = filename_from_url(
+                url=initial_url,
+                content_type=final_response.headers.get('Content-Type'),
+            )
+        unique_filename = get_unique_filename(filename)
+        return open(unique_filename, mode='a+b')
+
+
+class DownloadStatus:
+    """Holds details about the download status."""
+
+    def __init__(self):
+        self.downloaded = 0
+        self.total_size = None
+        self.resumed_from = 0
+        self.time_started = None
+        self.time_finished = None
+
+    def started(self, resumed_from=0, total_size=None):
+        assert self.time_started is None
+        self.total_size = total_size
+        self.downloaded = self.resumed_from = resumed_from
+        self.time_started = time()
+
+    def chunk_downloaded(self, size):
+        assert self.time_finished is None
+        self.downloaded += size
+
+    @property
+    def has_finished(self):
+        return self.time_finished is not None
+
+    def finished(self):
+        assert self.time_started is not None
+        assert self.time_finished is None
+        self.time_finished = time()
+
+
+class ProgressReporterThread(threading.Thread):
+    """
+    Reports download progress based on its status.
+
+    Uses threading to periodically update the status (speed, ETA, etc.).
+
+    """
+
+    def __init__(
+        self,
+        status: DownloadStatus,
+        output: IO,
+        tick=.1,
+        update_interval=1
+    ):
+        super().__init__()
+        self.status = status
+        self.output = output
+        self._tick = tick
+        self._update_interval = update_interval
+        self._spinner_pos = 0
+        self._status_line = ''
+        self._prev_bytes = 0
+        self._prev_time = time()
+        self._should_stop = threading.Event()
+
+    def stop(self):
+        """Stop reporting on next tick."""
+        self._should_stop.set()
+
+    def run(self):
+        while not self._should_stop.is_set():
+            if self.status.has_finished:
+                self.sum_up()
+                break
+
+            self.report_speed()
+            sleep(self._tick)
+
+    def report_speed(self):
+
+        now = time()
+
+        if now - self._prev_time >= self._update_interval:
+            downloaded = self.status.downloaded
+            try:
+                speed = ((downloaded - self._prev_bytes)
+                         / (now - self._prev_time))
+            except ZeroDivisionError:
+                speed = 0
+
+            if not self.status.total_size:
+                self._status_line = PROGRESS_NO_CONTENT_LENGTH.format(
+                    downloaded=humanize_bytes(downloaded),
+                    speed=humanize_bytes(speed),
+                )
+            else:
+                try:
+                    percentage = downloaded / self.status.total_size * 100
+                except ZeroDivisionError:
+                    percentage = 0
+
+                if not speed:
+                    eta = '-:--:--'
+                else:
+                    s = int((self.status.total_size - downloaded) / speed)
+                    h, s = divmod(s, 60 * 60)
+                    m, s = divmod(s, 60)
+                    eta = '{0}:{1:0>2}:{2:0>2}'.format(h, m, s)
+
+                self._status_line = PROGRESS.format(
+                    percentage=percentage,
+                    downloaded=humanize_bytes(downloaded),
+                    speed=humanize_bytes(speed),
+                    eta=eta,
+                )
+
+            self._prev_time = now
+            self._prev_bytes = downloaded
+
+        self.output.write(
+            CLEAR_LINE
+            + ' '
+            + SPINNER[self._spinner_pos]
+            + ' '
+            + self._status_line
+        )
+        self.output.flush()
+
+        self._spinner_pos = (self._spinner_pos + 1
+                             if self._spinner_pos + 1 != len(SPINNER)
+                             else 0)
+
+    def sum_up(self):
+        actually_downloaded = (
+            self.status.downloaded - self.status.resumed_from)
+        time_taken = self.status.time_finished - self.status.time_started
+
+        self.output.write(CLEAR_LINE)
+
+        try:
+            speed = actually_downloaded / time_taken
+        except ZeroDivisionError:
+            # Either time is 0 (not all systems provide `time.time`
+            # with a better precision than 1 second), and/or nothing
+            # has been downloaded.
+            speed = actually_downloaded
+
+        self.output.write(SUMMARY.format(
+            downloaded=humanize_bytes(actually_downloaded),
+            total=(self.status.total_size
+                   and humanize_bytes(self.status.total_size)),
+            speed=humanize_bytes(speed),
+            time=time_taken,
+        ))
+        self.output.flush()

httpie/input.py

@@ -1,540 +0,0 @@
-"""Parsing and processing of CLI input (args, auth credentials, files, stdin).
-
-"""
-import os
-import sys
-import re
-import json
-import mimetypes
-import getpass
-from io import BytesIO
-from argparse import ArgumentParser, ArgumentTypeError, ArgumentError
-
-try:
-    from collections import OrderedDict
-except ImportError:
-    OrderedDict = dict
-
-# TODO: Use MultiDict for headers once added to `requests`.
-# https://github.com/jkbr/httpie/issues/130
-from requests.structures import CaseInsensitiveDict
-
-from .compat import urlsplit, str
-
-
-HTTP_POST = 'POST'
-HTTP_GET = 'GET'
-HTTP = 'http://'
-HTTPS = 'https://'
-
-
-# Various separators used in args
-SEP_HEADERS = ':'
-SEP_CREDENTIALS = ':'
-SEP_PROXY = ':'
-SEP_DATA = '='
-SEP_DATA_RAW_JSON = ':='
-SEP_FILES = '@'
-SEP_QUERY = '=='
-
-# Separators that become request data
-SEP_GROUP_DATA_ITEMS = frozenset([
-    SEP_DATA,
-    SEP_DATA_RAW_JSON,
-    SEP_FILES
-])
-
-# Separators allowed in ITEM arguments
-SEP_GROUP_ITEMS = frozenset([
-    SEP_HEADERS,
-    SEP_QUERY,
-    SEP_DATA,
-    SEP_DATA_RAW_JSON,
-    SEP_FILES
-])
-
-
-# Output options
-OUT_REQ_HEAD = 'H'
-OUT_REQ_BODY = 'B'
-OUT_RESP_HEAD = 'h'
-OUT_RESP_BODY = 'b'
-
-OUTPUT_OPTIONS = frozenset([
-    OUT_REQ_HEAD,
-    OUT_REQ_BODY,
-    OUT_RESP_HEAD,
-    OUT_RESP_BODY
-])
-
-# Pretty
-PRETTY_MAP = {
-    'all': ['format', 'colors'],
-    'colors': ['colors'],
-    'format': ['format'],
-    'none': []
-}
-PRETTY_STDOUT_TTY_ONLY = object()
-
-
-# Defaults
-OUTPUT_OPTIONS_DEFAULT = OUT_RESP_HEAD + OUT_RESP_BODY
-OUTPUT_OPTIONS_DEFAULT_STDOUT_REDIRECTED = OUT_RESP_BODY
-
-
-class Parser(ArgumentParser):
-    """Adds additional logic to `argparse.ArgumentParser`.
-
-    Handles all input (CLI args, file args, stdin), applies defaults,
-    and performs extra validation.
-
-    """
-
-    def __init__(self, *args, **kwargs):
-        kwargs['add_help'] = False
-        super(Parser, self).__init__(*args, **kwargs)
-
-    #noinspection PyMethodOverriding
-    def parse_args(self, env, args=None, namespace=None):
-
-        self.env = env
-
-        args, no_options = super(Parser, self).parse_known_args(args,
-                                                                namespace)
-
-        self._apply_no_options(args, no_options)
-
-        if not args.json and env.config.implicit_content_type == 'form':
-            args.form = True
-
-        if args.debug:
-            args.traceback = True
-
-        if args.output:
-            env.stdout = args.output
-            env.stdout_isatty = False
-
-        self._process_output_options(args, env)
-        self._process_pretty_options(args, env)
-        self._guess_method(args, env)
-        self._parse_items(args)
-
-        if not env.stdin_isatty:
-            self._body_from_file(args, env.stdin)
-
-        if not (args.url.startswith(HTTP) or args.url.startswith(HTTPS)):
-            scheme = HTTPS if env.progname == 'https' else HTTP
-            args.url = scheme + args.url
-
-        self._process_auth(args)
-
-        return args
-
-    def _process_auth(self, args):
-        url = urlsplit(args.url)
-
-        if args.auth:
-            if not args.auth.has_password():
-                # Stdin already read (if not a tty) so it's save to prompt.
-                args.auth.prompt_password(url.netloc)
-
-        elif url.username is not None:
-            # Handle http://username:password@hostname/
-            username, password = url.username, url.password
-            args.auth = AuthCredentials(
-                key=username,
-                value=password,
-                sep=SEP_CREDENTIALS,
-                orig=SEP_CREDENTIALS.join([username, password])
-            )
-
-    def _apply_no_options(self, args, no_options):
-        """For every `--no-OPTION` in `no_options`, set `args.OPTION` to
-        its default value. This allows for un-setting of options, e.g.,
-        specified in config.
-
-        """
-        invalid = []
-
-        for option in no_options:
-            if not option.startswith('--no-'):
-                invalid.append(option)
-                continue
-
-            # --no-option => --option
-            inverted = '--' + option[5:]
-            for action in self._actions:
-                if inverted in action.option_strings:
-                    setattr(args, action.dest, action.default)
-                    break
-            else:
-                invalid.append(option)
-
-        if invalid:
-            msg = 'unrecognized arguments: %s'
-            self.error(msg % ' '.join(invalid))
-
-    def _print_message(self, message, file=None):
-        # Sneak in our stderr/stdout.
-        file = {
-            sys.stdout: self.env.stdout,
-            sys.stderr: self.env.stderr,
-            None: self.env.stderr
-        }.get(file, file)
-
-        super(Parser, self)._print_message(message, file)
-
-    def _body_from_file(self, args, fd):
-        """There can only be one source of request data.
-
-        Bytes are always read.
-
-        """
-        if args.data:
-            self.error('Request body (from stdin or a file) and request '
-                       'data (key=value) cannot be mixed.')
-        args.data = getattr(fd, 'buffer', fd).read()
-
-    def _guess_method(self, args, env):
-        """Set `args.method` if not specified to either POST or GET
-        based on whether the request has data or not.
-
-        """
-        if args.method is None:
-            # Invoked as `http URL'.
-            assert not args.items
-            if not env.stdin_isatty:
-                args.method = HTTP_POST
-            else:
-                args.method = HTTP_GET
-
-        # FIXME: False positive, e.g., "localhost" matches but is a valid URL.
-        elif not re.match('^[a-zA-Z]+$', args.method):
-            # Invoked as `http URL item+'. The URL is now in `args.method`
-            # and the first ITEM is now incorrectly in `args.url`.
-            try:
-                # Parse the URL as an ITEM and store it as the first ITEM arg.
-                args.items.insert(
-                    0, KeyValueArgType(*SEP_GROUP_ITEMS).__call__(args.url))
-
-            except ArgumentTypeError as e:
-                if args.traceback:
-                    raise
-                self.error(e.message)
-
-            else:
-                # Set the URL correctly
-                args.url = args.method
-                # Infer the method
-                has_data = not env.stdin_isatty or any(
-                    item.sep in SEP_GROUP_DATA_ITEMS for item in args.items)
-                args.method = HTTP_POST if has_data else HTTP_GET
-
-    def _parse_items(self, args):
-        """Parse `args.items` into `args.headers`, `args.data`,
-        `args.`, and `args.files`.
-
-        """
-        args.headers = CaseInsensitiveDict()
-        args.data = ParamDict() if args.form else OrderedDict()
-        args.files = OrderedDict()
-        args.params = ParamDict()
-
-        try:
-            parse_items(items=args.items,
-                        headers=args.headers,
-                        data=args.data,
-                        files=args.files,
-                        params=args.params)
-        except ParseError as e:
-            if args.traceback:
-                raise
-            self.error(e.message)
-
-        if args.files and not args.form:
-            # `http url @/path/to/file`
-            file_fields = list(args.files.keys())
-            if file_fields != ['']:
-                self.error(
-                    'Invalid file fields (perhaps you meant --form?): %s'
-                    % ','.join(file_fields))
-
-            fn, fd = args.files['']
-            args.files = {}
-            self._body_from_file(args, fd)
-            if 'Content-Type' not in args.headers:
-                mime, encoding = mimetypes.guess_type(fn, strict=False)
-                if mime:
-                    content_type = mime
-                    if encoding:
-                        content_type = '%s; charset=%s' % (mime, encoding)
-                    args.headers['Content-Type'] = content_type
-
-    def _process_output_options(self, args, env):
-        """Apply defaults to output options or validate the provided ones.
-
-        The default output options are stdout-type-sensitive.
-
-        """
-        if not args.output_options:
-            args.output_options = (OUTPUT_OPTIONS_DEFAULT if env.stdout_isatty
-                                else OUTPUT_OPTIONS_DEFAULT_STDOUT_REDIRECTED)
-
-        unknown = set(args.output_options) - OUTPUT_OPTIONS
-        if unknown:
-            self.error('Unknown output options: %s' % ','.join(unknown))
-
-    def _process_pretty_options(self, args, env):
-        if args.prettify == PRETTY_STDOUT_TTY_ONLY:
-            args.prettify = PRETTY_MAP['all' if env.stdout_isatty else 'none']
-        elif args.prettify and env.is_windows:
-            self.error('Only terminal output can be colorized on Windows.')
-        else:
-            args.prettify = PRETTY_MAP[args.prettify]
-
-
-class ParseError(Exception):
-    pass
-
-
-class KeyValue(object):
-    """Base key-value pair parsed from CLI."""
-
-    def __init__(self, key, value, sep, orig):
-        self.key = key
-        self.value = value
-        self.sep = sep
-        self.orig = orig
-
-    def __eq__(self, other):
-        return self.__dict__ == other.__dict__
-
-
-def session_name_arg_type(name):
-    from .sessions import Session
-    if not Session.is_valid_name(name):
-        raise ArgumentTypeError(
-            'special characters and spaces are not'
-            ' allowed in session names: "%s"'
-            % name)
-    return name
-
-
-def host_name_arg_type(name):
-    from .sessions import Host
-    if not Host.is_valid_name(name):
-        raise ArgumentTypeError(
-            'special characters and spaces are not'
-            ' allowed in host names: "%s"'
-            % name)
-    return name
-
-
-class RegexValidator(object):
-
-    def __init__(self, pattern, error_message):
-        self.pattern = re.compile(pattern)
-        self.error_message = error_message
-
-    def __call__(self, value):
-        if not self.pattern.search(value):
-            raise ArgumentError(None, self.error_message)
-        return value
-
-
-class KeyValueArgType(object):
-    """A key-value pair argument type used with `argparse`.
-
-    Parses a key-value arg and constructs a `KeyValue` instance.
-    Used for headers, form data, and other key-value pair types.
-
-    """
-
-    key_value_class = KeyValue
-
-    def __init__(self, *separators):
-        self.separators = separators
-
-    def __call__(self, string):
-        """Parse `string` and return `self.key_value_class()` instance.
-
-        The best of `self.separators` is determined (first found, longest).
-        Back slash escaped characters aren't considered as separators
-        (or parts thereof). Literal back slash characters have to be escaped
-        as well (r'\\').
-
-        """
-
-        class Escaped(str):
-            """Represents an escaped character."""
-
-        def tokenize(s):
-            """Tokenize `s`. There are only two token types - strings
-            and escaped characters:
-
-            >>> tokenize(r'foo\=bar\\baz')
-            ['foo', Escaped('='), 'bar', Escaped('\\'), 'baz']
-
-            """
-            tokens = ['']
-            esc = False
-            for c in s:
-                if esc:
-                    tokens.extend([Escaped(c), ''])
-                    esc = False
-                else:
-                    if c == '\\':
-                        esc = True
-                    else:
-                        tokens[-1] += c
-            return tokens
-
-        tokens = tokenize(string)
-
-        # Sorting by length ensures that the longest one will be
-        # chosen as it will overwrite any shorter ones starting
-        # at the same position in the `found` dictionary.
-        separators = sorted(self.separators, key=len)
-
-        for i, token in enumerate(tokens):
-
-            if isinstance(token, Escaped):
-                continue
-
-            found = {}
-            for sep in separators:
-                pos = token.find(sep)
-                if pos != -1:
-                    found[pos] = sep
-
-            if found:
-                # Starting first, longest separator found.
-                sep = found[min(found.keys())]
-
-                key, value = token.split(sep, 1)
-
-                # Any preceding tokens are part of the key.
-                key = ''.join(tokens[:i]) + key
-
-                # Any following tokens are part of the value.
-                value += ''.join(tokens[i + 1:])
-
-                break
-
-        else:
-            raise ArgumentTypeError(
-                '"%s" is not a valid value' % string)
-
-        return self.key_value_class(
-            key=key, value=value, sep=sep, orig=string)
-
-
-class AuthCredentials(KeyValue):
-    """Represents parsed credentials."""
-
-    def _getpass(self, prompt):
-        # To allow mocking.
-        return getpass.getpass(prompt)
-
-    def has_password(self):
-        return self.value is not None
-
-    def prompt_password(self, host):
-        try:
-            self.value = self._getpass(
-                'http: password for %s@%s: ' % (self.key, host))
-        except (EOFError, KeyboardInterrupt):
-            sys.stderr.write('\n')
-            sys.exit(0)
-
-
-class AuthCredentialsArgType(KeyValueArgType):
-    """A key-value arg type that parses credentials."""
-
-    key_value_class = AuthCredentials
-
-    def __call__(self, string):
-        """Parse credentials from `string`.
-
-        ("username" or "username:password").
-
-        """
-        try:
-            return super(AuthCredentialsArgType, self).__call__(string)
-        except ArgumentTypeError:
-            # No password provided, will prompt for it later.
-            return self.key_value_class(
-                key=string,
-                value=None,
-                sep=SEP_CREDENTIALS,
-                orig=string
-            )
-
-
-class ParamDict(OrderedDict):
-    """Multi-value dict for URL parameters and form data."""
-
-    #noinspection PyMethodOverriding
-    def __setitem__(self, key, value):
-        """ If `key` is assigned more than once, `self[key]` holds a
-        `list` of all the values.
-
-        This allows having multiple fields with the same name in form
-        data and URL params.
-
-        """
-        if key not in self:
-            super(ParamDict, self).__setitem__(key, value)
-        else:
-            if not isinstance(self[key], list):
-                super(ParamDict, self).__setitem__(key, [self[key]])
-            self[key].append(value)
-
-
-def parse_items(items, data=None, headers=None, files=None, params=None):
-    """Parse `KeyValue` `items` into `data`, `headers`, `files`,
-    and `params`.
-
-    """
-    if headers is None:
-        headers = CaseInsensitiveDict()
-    if data is None:
-        data = OrderedDict()
-    if files is None:
-        files = OrderedDict()
-    if params is None:
-        params = ParamDict()
-
-    for item in items:
-
-        value = item.value
-        key = item.key
-
-        if item.sep == SEP_HEADERS:
-            target = headers
-        elif item.sep == SEP_QUERY:
-            target = params
-        elif item.sep == SEP_FILES:
-            try:
-                with open(os.path.expanduser(value), 'rb') as f:
-                    value = (os.path.basename(value),
-                             BytesIO(f.read()))
-            except IOError as e:
-                raise ParseError(
-                    'Invalid argument "%s": %s' % (item.orig, e))
-            target = files
-
-        elif item.sep in [SEP_DATA, SEP_DATA_RAW_JSON]:
-            if item.sep == SEP_DATA_RAW_JSON:
-                try:
-                    value = json.loads(item.value)
-                except ValueError:
-                    raise ParseError('"%s" is not valid JSON' % item.orig)
-            target = data
-
-        else:
-            raise TypeError(item)
-
-        target[key] = value
-
-    return headers, data, files, params

httpie/models.py

@@ -1,92 +1,42 @@
-import os
-import sys
-
-from .config import DEFAULT_CONFIG_DIR, Config
-from .compat import urlsplit, is_windows, bytes, str
+from typing import Iterable, Optional
+from urllib.parse import urlsplit
 
 
-class Environment(object):
-    """Holds information about the execution context.
-
-    Groups various aspects of the environment in a changeable object
-    and allows for mocking.
-
-    """
-
-    is_windows = is_windows
-
-    progname = os.path.basename(sys.argv[0])
-    if progname not in ['http', 'https']:
-        progname = 'http'
-
-    stdin_isatty = sys.stdin.isatty()
-    stdin = sys.stdin
-    stdout_isatty = sys.stdout.isatty()
-
-    config_dir = DEFAULT_CONFIG_DIR
-
-    if stdout_isatty and is_windows:
-        from colorama.initialise import wrap_stream
-        stdout = wrap_stream(sys.stdout, convert=None,
-                             strip=None, autoreset=True, wrap=True)
-    else:
-        stdout = sys.stdout
-    stderr = sys.stderr
-
-    # Can be set to 0 to disable colors completely.
-    colors = 256 if '256color' in os.environ.get('TERM', '') else 88
-
-    def __init__(self, **kwargs):
-        assert all(hasattr(type(self), attr)
-                   for attr in kwargs.keys())
-        self.__dict__.update(**kwargs)
-
-    @property
-    def config(self):
-        if not hasattr(self, '_config'):
-            self._config = Config(directory=self.config_dir)
-            if self._config.is_new:
-                self._config.save()
-            else:
-                self._config.load()
-        return self._config
-
-
-class HTTPMessage(object):
+class HTTPMessage:
     """Abstract class for HTTP messages."""
 
     def __init__(self, orig):
         self._orig = orig
 
-    def iter_body(self, chunk_size):
+    def iter_body(self, chunk_size: int) -> Iterable[bytes]:
         """Return an iterator over the body."""
         raise NotImplementedError()
 
-    def iter_lines(self, chunk_size):
+    def iter_lines(self, chunk_size: int) -> Iterable[bytes]:
         """Return an iterator over the body yielding (`line`, `line_feed`)."""
         raise NotImplementedError()
 
     @property
-    def headers(self):
+    def headers(self) -> str:
         """Return a `str` with the message's headers."""
         raise NotImplementedError()
 
     @property
-    def encoding(self):
+    def encoding(self) -> Optional[str]:
         """Return a `str` with the message's encoding, if known."""
         raise NotImplementedError()
 
     @property
-    def body(self):
+    def body(self) -> bytes:
         """Return a `bytes` with the message's body."""
         raise NotImplementedError()
 
     @property
-    def content_type(self):
+    def content_type(self) -> str:
         """Return the message content type."""
         ct = self._orig.headers.get('Content-Type', '')
-        if isinstance(ct, bytes):
-            ct = ct.decode()
+        if not isinstance(ct, str):
+            ct = ct.decode('utf8')
         return ct
 
 
@@ -99,14 +49,19 @@ class HTTPResponse(HTTPMessage):
     def iter_lines(self, chunk_size):
         return ((line, b'\n') for line in self._orig.iter_lines(chunk_size))
 
+    # noinspection PyProtectedMember
     @property
     def headers(self):
         original = self._orig.raw._original_response
-        status_line = 'HTTP/{version} {status} {reason}'.format(
-            version='.'.join(str(original.version)),
-            status=original.status,
-            reason=original.reason
-        )
+
+        version = {
+            9: '0.9',
+            10: '1.0',
+            11: '1.1',
+            20: '2',
+        }[original.version]
+
+        status_line = f'HTTP/{version} {original.status} {original.reason}'
         headers = [status_line]
         try:
             # `original.msg` is a `http.client.HTTPMessage` on Python 3
@@ -151,16 +106,24 @@ class HTTPRequest(HTTPMessage):
         )
 
         headers = dict(self._orig.headers)
+        if 'Host' not in self._orig.headers:
+            headers['Host'] = url.netloc.split('@')[-1]
 
-        if 'Host' not in headers:
-            headers['Host'] = url.netloc
-
-        headers = ['%s: %s' % (name, value)
-                   for name, value in headers.items()]
+        headers = [
+            '%s: %s' % (
+                name,
+                value if isinstance(value, str) else value.decode('utf8')
+            )
+            for name, value in headers.items()
+        ]
 
         headers.insert(0, request_line)
+        headers = '\r\n'.join(headers).strip()
 
-        return '\r\n'.join(headers).strip()
+        if isinstance(headers, bytes):
+            # Python < 3
+            headers = headers.decode('utf8')
+        return headers
 
     @property
     def encoding(self):

httpie/output.py

@@ -1,494 +0,0 @@
-"""Output streaming, processing and formatting.
-
-"""
-import json
-from functools import partial
-from itertools import chain
-
-import pygments
-from pygments import token, lexer
-from pygments.styles import get_style_by_name, STYLE_MAP
-from pygments.lexers import get_lexer_for_mimetype, get_lexer_by_name
-from pygments.formatters.terminal import TerminalFormatter
-from pygments.formatters.terminal256 import Terminal256Formatter
-from pygments.util import ClassNotFound
-
-from .compat import is_windows
-from .solarized import Solarized256Style
-from .models import HTTPRequest, HTTPResponse, Environment
-from .input import (OUT_REQ_BODY, OUT_REQ_HEAD,
-                    OUT_RESP_HEAD, OUT_RESP_BODY)
-
-
-# Colors on Windows via colorama don't look that
-# great and fruity seems to give the best result there.
-AVAILABLE_STYLES = set(STYLE_MAP.keys())
-AVAILABLE_STYLES.add('solarized')
-DEFAULT_STYLE = 'solarized' if not is_windows else 'fruity'
-
-
-BINARY_SUPPRESSED_NOTICE = (
-    b'\n'
-    b'+-----------------------------------------+\n'
-    b'| NOTE: binary data not shown in terminal |\n'
-    b'+-----------------------------------------+'
-)
-
-
-class BinarySuppressedError(Exception):
-    """An error indicating that the body is binary and won't be written,
-     e.g., for terminal output)."""
-
-    message = BINARY_SUPPRESSED_NOTICE
-
-
-###############################################################################
-# Output Streams
-###############################################################################
-
-
-def write(stream, outfile, flush):
-    """Write the output stream."""
-    try:
-        # Writing bytes so we use the buffer interface (Python 3).
-        buf = outfile.buffer
-    except AttributeError:
-        buf = outfile
-
-    for chunk in stream:
-        buf.write(chunk)
-        if flush:
-            outfile.flush()
-
-
-def write_with_colors_win_p3k(stream, outfile, flush):
-    """Like `write`, but colorized chunks are written as text
-    directly to `outfile` to ensure it gets processed by colorama.
-    Applies only to Windows with Python 3 and colorized terminal output.
-
-    """
-    color = b'\x1b['
-    encoding = outfile.encoding
-    for chunk in stream:
-        if color in chunk:
-            outfile.write(chunk.decode(encoding))
-        else:
-            outfile.buffer.write(chunk)
-        if flush:
-            outfile.flush()
-
-
-def build_output_stream(args, env, request, response):
-    """Build and return a chain of iterators over the `request`-`response`
-    exchange each of which yields `bytes` chunks.
-
-    """
-
-    req_h = OUT_REQ_HEAD in args.output_options
-    req_b = OUT_REQ_BODY in args.output_options
-    resp_h = OUT_RESP_HEAD in args.output_options
-    resp_b = OUT_RESP_BODY in args.output_options
-    req = req_h or req_b
-    resp = resp_h or resp_b
-
-    output = []
-    Stream = get_stream_type(env, args)
-
-    if req:
-        output.append(Stream(
-            msg=HTTPRequest(request),
-            with_headers=req_h,
-            with_body=req_b))
-
-    if req_b and resp:
-        # Request/Response separator.
-        output.append([b'\n\n'])
-
-    if resp:
-        output.append(Stream(
-            msg=HTTPResponse(response),
-            with_headers=resp_h,
-            with_body=resp_b))
-
-    if env.stdout_isatty and resp_b:
-        # Ensure a blank line after the response body.
-        # For terminal output only.
-        output.append([b'\n\n'])
-
-    return chain(*output)
-
-
-def get_stream_type(env, args):
-    """Pick the right stream type based on `env` and `args`.
-    Wrap it in a partial with the type-specific args so that
-    we don't need to think what stream we are dealing with.
-
-    """
-    if not env.stdout_isatty and not args.prettify:
-        Stream = partial(
-            RawStream,
-            chunk_size=RawStream.CHUNK_SIZE_BY_LINE
-                       if args.stream
-                       else RawStream.CHUNK_SIZE
-        )
-    elif args.prettify:
-        Stream = partial(
-            PrettyStream if args.stream else BufferedPrettyStream,
-            env=env,
-            processor=OutputProcessor(
-                env=env, groups=args.prettify, pygments_style=args.style),
-        )
-    else:
-        Stream = partial(EncodedStream, env=env)
-
-    return Stream
-
-
-class BaseStream(object):
-    """Base HTTP message output stream class."""
-
-    def __init__(self, msg, with_headers=True, with_body=True):
-        """
-        :param msg: a :class:`models.HTTPMessage` subclass
-        :param with_headers: if `True`, headers will be included
-        :param with_body: if `True`, body will be included
-
-        """
-        assert with_headers or with_body
-        self.msg = msg
-        self.with_headers = with_headers
-        self.with_body = with_body
-
-    def _get_headers(self):
-        """Return the headers' bytes."""
-        return self.msg.headers.encode('ascii')
-
-    def _iter_body(self):
-        """Return an iterator over the message body."""
-        raise NotImplementedError()
-
-    def __iter__(self):
-        """Return an iterator over `self.msg`."""
-        if self.with_headers:
-            yield self._get_headers()
-            yield b'\r\n\r\n'
-
-        if self.with_body:
-            try:
-                for chunk in self._iter_body():
-                    yield chunk
-            except BinarySuppressedError as e:
-                if self.with_headers:
-                    yield b'\n'
-                yield e.message
-
-
-class RawStream(BaseStream):
-    """The message is streamed in chunks with no processing."""
-
-    CHUNK_SIZE = 1024 * 100
-    CHUNK_SIZE_BY_LINE = 1024 * 5
-
-    def __init__(self, chunk_size=CHUNK_SIZE, **kwargs):
-        super(RawStream, self).__init__(**kwargs)
-        self.chunk_size = chunk_size
-
-    def _iter_body(self):
-        return self.msg.iter_body(self.chunk_size)
-
-
-class EncodedStream(BaseStream):
-    """Encoded HTTP message stream.
-
-    The message bytes are converted to an encoding suitable for
-    `self.env.stdout`. Unicode errors are replaced and binary data
-    is suppressed. The body is always streamed by line.
-
-    """
-    CHUNK_SIZE = 1024 * 5
-
-    def __init__(self, env=Environment(), **kwargs):
-
-        super(EncodedStream, self).__init__(**kwargs)
-
-        if env.stdout_isatty:
-            # Use the encoding supported by the terminal.
-            output_encoding = getattr(env.stdout, 'encoding', None)
-        else:
-            # Preserve the message encoding.
-            output_encoding = self.msg.encoding
-
-        # Default to utf8 when unsure.
-        self.output_encoding = output_encoding or 'utf8'
-
-    def _iter_body(self):
-
-        for line, lf in self.msg.iter_lines(self.CHUNK_SIZE):
-
-            if b'\0' in line:
-                raise BinarySuppressedError()
-
-            yield line.decode(self.msg.encoding)\
-                      .encode(self.output_encoding, 'replace') + lf
-
-
-class PrettyStream(EncodedStream):
-    """In addition to :class:`EncodedStream` behaviour, this stream applies
-    content processing.
-
-    Useful for long-lived HTTP responses that stream by lines
-    such as the Twitter streaming API.
-
-    """
-
-    CHUNK_SIZE = 1024 * 5
-
-    def __init__(self, processor, **kwargs):
-        super(PrettyStream, self).__init__(**kwargs)
-        self.processor = processor
-
-    def _get_headers(self):
-        return self.processor.process_headers(
-            self.msg.headers).encode(self.output_encoding)
-
-    def _iter_body(self):
-        for line, lf in self.msg.iter_lines(self.CHUNK_SIZE):
-            if b'\0' in line:
-                raise BinarySuppressedError()
-            yield self._process_body(line) + lf
-
-    def _process_body(self, chunk):
-        return (self.processor
-                    .process_body(
-                        chunk.decode(self.msg.encoding, 'replace'),
-                        self.msg.content_type)
-                    .encode(self.output_encoding, 'replace'))
-
-
-class BufferedPrettyStream(PrettyStream):
-    """The same as :class:`PrettyStream` except that the body is fully
-    fetched before it's processed.
-
-    Suitable regular HTTP responses.
-
-    """
-
-    CHUNK_SIZE = 1024 * 10
-
-    def _iter_body(self):
-
-        # Read the whole body before prettifying it,
-        # but bail out immediately if the body is binary.
-        body = bytearray()
-        for chunk in self.msg.iter_body(self.CHUNK_SIZE):
-            if b'\0' in chunk:
-                raise BinarySuppressedError()
-            body.extend(chunk)
-
-        yield self._process_body(body)
-
-
-###############################################################################
-# Processing
-###############################################################################
-
-class HTTPLexer(lexer.RegexLexer):
-    """Simplified HTTP lexer for Pygments.
-
-    It only operates on headers and provides a stronger contrast between
-    their names and values than the original one bundled with Pygments
-    (:class:`pygments.lexers.text import HttpLexer`), especially when
-    Solarized color scheme is used.
-
-    """
-    name = 'HTTP'
-    aliases = ['http']
-    filenames = ['*.http']
-    tokens = {
-        'root': [
-            # Request-Line
-            (r'([A-Z]+)( +)([^ ]+)( +)(HTTP)(/)(\d+\.\d+)',
-             lexer.bygroups(
-                 token.Name.Function,
-                 token.Text,
-                 token.Name.Namespace,
-                 token.Text,
-                 token.Keyword.Reserved,
-                 token.Operator,
-                 token.Number
-             )),
-            # Response Status-Line
-            (r'(HTTP)(/)(\d+\.\d+)( +)(\d{3})( +)(.+)',
-             lexer.bygroups(
-                 token.Keyword.Reserved,  # 'HTTP'
-                 token.Operator,  # '/'
-                 token.Number,  # Version
-                 token.Text,
-                 token.Number,  # Status code
-                 token.Text,
-                 token.Name.Exception,  # Reason
-             )),
-            # Header
-            (r'(.*?)( *)(:)( *)(.+)', lexer.bygroups(
-                token.Name.Attribute,  # Name
-                token.Text,
-                token.Operator,  # Colon
-                token.Text,
-                token.String  # Value
-            ))
-        ]
-    }
-
-
-class BaseProcessor(object):
-    """Base, noop output processor class."""
-
-    enabled = True
-
-    def __init__(self, env=Environment(), **kwargs):
-        """
-        :param env: an class:`Environment` instance
-        :param kwargs: additional keyword argument that some
-                       processor might require.
-
-        """
-        self.env = env
-        self.kwargs = kwargs
-
-    def process_headers(self, headers):
-        """Return processed `headers`
-
-        :param headers: The headers as text.
-
-        """
-        return headers
-
-    def process_body(self, content, content_type, subtype):
-        """Return processed `content`.
-
-        :param content: The body content as text
-        :param content_type: Full content type, e.g., 'application/atom+xml'.
-        :param subtype: E.g. 'xml'.
-
-        """
-        return content
-
-
-class JSONProcessor(BaseProcessor):
-    """JSON body processor."""
-
-    def process_body(self, content, content_type, subtype):
-        if subtype == 'json':
-            try:
-                # Indent the JSON data, sort keys by name, and
-                # avoid unicode escapes to improve readability.
-                content = json.dumps(json.loads(content),
-                                     sort_keys=True,
-                                     ensure_ascii=False,
-                                     indent=4)
-            except ValueError:
-                # Invalid JSON but we don't care.
-                pass
-        return content
-
-
-class PygmentsProcessor(BaseProcessor):
-    """A processor that applies syntax-highlighting using Pygments
-    to the headers, and to the body as well if its content type is recognized.
-
-    """
-    def __init__(self, *args, **kwargs):
-        super(PygmentsProcessor, self).__init__(*args, **kwargs)
-
-        # Cache that speeds up when we process streamed body by line.
-        self.lexers_by_type = {}
-
-        if not self.env.colors:
-            self.enabled = False
-            return
-
-        try:
-            style = get_style_by_name(
-                self.kwargs.get('pygments_style', DEFAULT_STYLE))
-        except ClassNotFound:
-            style = Solarized256Style
-
-        if self.env.is_windows or self.env.colors == 256:
-            fmt_class = Terminal256Formatter
-        else:
-            fmt_class = TerminalFormatter
-        self.formatter = fmt_class(style=style)
-
-    def process_headers(self, headers):
-        return pygments.highlight(
-            headers, HTTPLexer(), self.formatter).strip()
-
-    def process_body(self, content, content_type, subtype):
-        try:
-            lexer = self.lexers_by_type.get(content_type)
-            if not lexer:
-                try:
-                    lexer = get_lexer_for_mimetype(content_type)
-                except ClassNotFound:
-                    lexer = get_lexer_by_name(subtype)
-                self.lexers_by_type[content_type] = lexer
-        except ClassNotFound:
-            pass
-        else:
-            content = pygments.highlight(content, lexer, self.formatter)
-        return content.strip()
-
-
-class HeadersProcessor(BaseProcessor):
-    """Sorts headers by name retaining relative order of multiple headers
-    with the same name.
-
-    """
-    def process_headers(self, headers):
-        lines = headers.splitlines()
-        headers = sorted(lines[1:], key=lambda h: h.split(':')[0])
-        return '\r\n'.join(lines[:1] + headers)
-
-
-class OutputProcessor(object):
-    """A delegate class that invokes the actual processors."""
-
-    installed_processors = {
-        'format': [
-            HeadersProcessor,
-            JSONProcessor
-        ],
-        'colors': [
-            PygmentsProcessor
-        ]
-    }
-
-    def __init__(self, groups, env=Environment(), **kwargs):
-        """
-        :param env: a :class:`models.Environment` instance
-        :param groups: the groups of processors to be applied
-        :param kwargs: additional keyword arguments for processors
-
-        """
-        self.processors = []
-        for group in groups:
-            for cls in self.installed_processors[group]:
-                processor = cls(env, **kwargs)
-                if processor.enabled:
-                    self.processors.append(processor)
-
-    def process_headers(self, headers):
-        for processor in self.processors:
-            headers = processor.process_headers(headers)
-        return headers
-
-    def process_body(self, content, content_type):
-        # e.g., 'application/atom+xml'
-        content_type = content_type.split(';')[0]
-        # e.g., 'xml'
-        subtype = content_type.split('/')[-1].split('+')[-1]
-
-        for processor in self.processors:
-            content = processor.process_body(content, content_type, subtype)
-
-        return content

httpie/output/formatters/colors.py

@@ -0,0 +1,276 @@
+from __future__ import absolute_import
+
+import json
+from typing import Optional, Type
+
+import pygments.lexer
+import pygments.lexers
+import pygments.style
+import pygments.styles
+import pygments.token
+from pygments.formatters.terminal import TerminalFormatter
+from pygments.formatters.terminal256 import Terminal256Formatter
+from pygments.lexer import Lexer
+from pygments.lexers.special import TextLexer
+from pygments.lexers.text import HttpLexer as PygmentsHttpLexer
+from pygments.util import ClassNotFound
+
+from httpie.compat import is_windows
+from httpie.context import Environment
+from httpie.plugins import FormatterPlugin
+
+
+AUTO_STYLE = 'auto'  # Follows terminal ANSI color styles
+DEFAULT_STYLE = AUTO_STYLE
+SOLARIZED_STYLE = 'solarized'  # Bundled here
+if is_windows:
+    # Colors on Windows via colorama don't look that
+    # great and fruity seems to give the best result there.
+    DEFAULT_STYLE = 'fruity'
+
+AVAILABLE_STYLES = set(pygments.styles.get_all_styles())
+AVAILABLE_STYLES.add(SOLARIZED_STYLE)
+AVAILABLE_STYLES.add(AUTO_STYLE)
+
+
+class ColorFormatter(FormatterPlugin):
+    """
+    Colorize using Pygments
+
+    This processor that applies syntax highlighting to the headers,
+    and also to the body if its content type is recognized.
+
+    """
+    group_name = 'colors'
+
+    def __init__(
+        self,
+        env: Environment,
+        explicit_json=False,
+        color_scheme=DEFAULT_STYLE,
+        **kwargs
+    ):
+        super().__init__(**kwargs)
+
+        if not env.colors:
+            self.enabled = False
+            return
+
+        use_auto_style = color_scheme == AUTO_STYLE
+        has_256_colors = env.colors == 256
+        if use_auto_style or not has_256_colors:
+            http_lexer = PygmentsHttpLexer()
+            formatter = TerminalFormatter()
+        else:
+            http_lexer = SimplifiedHTTPLexer()
+            formatter = Terminal256Formatter(
+                style=self.get_style_class(color_scheme)
+            )
+
+        self.explicit_json = explicit_json  # --json
+        self.formatter = formatter
+        self.http_lexer = http_lexer
+
+    def format_headers(self, headers: str) -> str:
+        return pygments.highlight(
+            code=headers,
+            lexer=self.http_lexer,
+            formatter=self.formatter,
+        ).strip()
+
+    def format_body(self, body: str, mime: str) -> str:
+        lexer = self.get_lexer_for_body(mime, body)
+        if lexer:
+            body = pygments.highlight(
+                code=body,
+                lexer=lexer,
+                formatter=self.formatter,
+            )
+        return body
+
+    def get_lexer_for_body(
+        self, mime: str,
+        body: str
+    ) -> Optional[Type[Lexer]]:
+        return get_lexer(
+            mime=mime,
+            explicit_json=self.explicit_json,
+            body=body,
+        )
+
+    @staticmethod
+    def get_style_class(color_scheme: str) -> Type[pygments.style.Style]:
+        try:
+            return pygments.styles.get_style_by_name(color_scheme)
+        except ClassNotFound:
+            return Solarized256Style
+
+
+def get_lexer(
+    mime: str,
+    explicit_json=False,
+    body=''
+) -> Optional[Type[Lexer]]:
+    # Build candidate mime type and lexer names.
+    mime_types, lexer_names = [mime], []
+    type_, subtype = mime.split('/', 1)
+    if '+' not in subtype:
+        lexer_names.append(subtype)
+    else:
+        subtype_name, subtype_suffix = subtype.split('+', 1)
+        lexer_names.extend([subtype_name, subtype_suffix])
+        mime_types.extend([
+            '%s/%s' % (type_, subtype_name),
+            '%s/%s' % (type_, subtype_suffix)
+        ])
+
+    # As a last resort, if no lexer feels responsible, and
+    # the subtype contains 'json', take the JSON lexer
+    if 'json' in subtype:
+        lexer_names.append('json')
+
+    # Try to resolve the right lexer.
+    lexer = None
+    for mime_type in mime_types:
+        try:
+            lexer = pygments.lexers.get_lexer_for_mimetype(mime_type)
+            break
+        except ClassNotFound:
+            pass
+    else:
+        for name in lexer_names:
+            try:
+                lexer = pygments.lexers.get_lexer_by_name(name)
+            except ClassNotFound:
+                pass
+
+    if explicit_json and body and (not lexer or isinstance(lexer, TextLexer)):
+        # JSON response with an incorrect Content-Type?
+        try:
+            json.loads(body)  # FIXME: the body also gets parsed in json.py
+        except ValueError:
+            pass  # Nope
+        else:
+            lexer = pygments.lexers.get_lexer_by_name('json')
+
+    return lexer
+
+
+class SimplifiedHTTPLexer(pygments.lexer.RegexLexer):
+    """Simplified HTTP lexer for Pygments.
+
+    It only operates on headers and provides a stronger contrast between
+    their names and values than the original one bundled with Pygments
+    (:class:`pygments.lexers.text import HttpLexer`), especially when
+    Solarized color scheme is used.
+
+    """
+    name = 'HTTP'
+    aliases = ['http']
+    filenames = ['*.http']
+    tokens = {
+        'root': [
+            # Request-Line
+            (r'([A-Z]+)( +)([^ ]+)( +)(HTTP)(/)(\d+\.\d+)',
+             pygments.lexer.bygroups(
+                 pygments.token.Name.Function,
+                 pygments.token.Text,
+                 pygments.token.Name.Namespace,
+                 pygments.token.Text,
+                 pygments.token.Keyword.Reserved,
+                 pygments.token.Operator,
+                 pygments.token.Number
+             )),
+            # Response Status-Line
+            (r'(HTTP)(/)(\d+\.\d+)( +)(\d{3})( +)(.+)',
+             pygments.lexer.bygroups(
+                 pygments.token.Keyword.Reserved,  # 'HTTP'
+                 pygments.token.Operator,  # '/'
+                 pygments.token.Number,  # Version
+                 pygments.token.Text,
+                 pygments.token.Number,  # Status code
+                 pygments.token.Text,
+                 pygments.token.Name.Exception,  # Reason
+             )),
+            # Header
+            (r'(.*?)( *)(:)( *)(.+)', pygments.lexer.bygroups(
+                pygments.token.Name.Attribute,  # Name
+                pygments.token.Text,
+                pygments.token.Operator,  # Colon
+                pygments.token.Text,
+                pygments.token.String  # Value
+            ))
+        ]
+    }
+
+
+class Solarized256Style(pygments.style.Style):
+    """
+    solarized256
+    ------------
+
+    A Pygments style inspired by Solarized's 256 color mode.
+
+    :copyright: (c) 2011 by Hank Gay, (c) 2012 by John Mastro.
+    :license: BSD, see LICENSE for more details.
+
+    """
+    BASE03 = "#1c1c1c"
+    BASE02 = "#262626"
+    BASE01 = "#4e4e4e"
+    BASE00 = "#585858"
+    BASE0 = "#808080"
+    BASE1 = "#8a8a8a"
+    BASE2 = "#d7d7af"
+    BASE3 = "#ffffd7"
+    YELLOW = "#af8700"
+    ORANGE = "#d75f00"
+    RED = "#af0000"
+    MAGENTA = "#af005f"
+    VIOLET = "#5f5faf"
+    BLUE = "#0087ff"
+    CYAN = "#00afaf"
+    GREEN = "#5f8700"
+
+    background_color = BASE03
+    styles = {
+        pygments.token.Keyword: GREEN,
+        pygments.token.Keyword.Constant: ORANGE,
+        pygments.token.Keyword.Declaration: BLUE,
+        pygments.token.Keyword.Namespace: ORANGE,
+        pygments.token.Keyword.Reserved: BLUE,
+        pygments.token.Keyword.Type: RED,
+        pygments.token.Name.Attribute: BASE1,
+        pygments.token.Name.Builtin: BLUE,
+        pygments.token.Name.Builtin.Pseudo: BLUE,
+        pygments.token.Name.Class: BLUE,
+        pygments.token.Name.Constant: ORANGE,
+        pygments.token.Name.Decorator: BLUE,
+        pygments.token.Name.Entity: ORANGE,
+        pygments.token.Name.Exception: YELLOW,
+        pygments.token.Name.Function: BLUE,
+        pygments.token.Name.Tag: BLUE,
+        pygments.token.Name.Variable: BLUE,
+        pygments.token.String: CYAN,
+        pygments.token.String.Backtick: BASE01,
+        pygments.token.String.Char: CYAN,
+        pygments.token.String.Doc: CYAN,
+        pygments.token.String.Escape: RED,
+        pygments.token.String.Heredoc: CYAN,
+        pygments.token.String.Regex: RED,
+        pygments.token.Number: CYAN,
+        pygments.token.Operator: BASE1,
+        pygments.token.Operator.Word: GREEN,
+        pygments.token.Comment: BASE01,
+        pygments.token.Comment.Preproc: GREEN,
+        pygments.token.Comment.Special: GREEN,
+        pygments.token.Generic.Deleted: CYAN,
+        pygments.token.Generic.Emph: 'italic',
+        pygments.token.Generic.Error: RED,
+        pygments.token.Generic.Heading: ORANGE,
+        pygments.token.Generic.Inserted: GREEN,
+        pygments.token.Generic.Strong: 'bold',
+        pygments.token.Generic.Subheading: ORANGE,
+        pygments.token.Token: BASE1,
+        pygments.token.Token.Other: ORANGE,
+    }

httpie/output/formatters/headers.py

@@ -0,0 +1,18 @@
+from httpie.plugins import FormatterPlugin
+
+
+class HeadersFormatter(FormatterPlugin):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.enabled = self.format_options['headers']['sort']
+
+    def format_headers(self, headers: str) -> str:
+        """
+        Sorts headers by name while retaining relative
+        order of multiple headers with the same name.
+
+        """
+        lines = headers.splitlines()
+        headers = sorted(lines[1:], key=lambda h: h.split(':')[0])
+        return '\r\n'.join(lines[:1] + headers)

httpie/output/formatters/json.py

@@ -0,0 +1,34 @@
+from __future__ import absolute_import
+import json
+
+from httpie.plugins import FormatterPlugin
+
+
+class JSONFormatter(FormatterPlugin):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.enabled = self.format_options['json']['format']
+
+    def format_body(self, body: str, mime: str) -> str:
+        maybe_json = [
+            'json',
+            'javascript',
+            'text',
+        ]
+        if (self.kwargs['explicit_json']
+                or any(token in mime for token in maybe_json)):
+            try:
+                obj = json.loads(body)
+            except ValueError:
+                pass  # Invalid JSON, ignore.
+            else:
+                # Indent, sort keys by name, and avoid
+                # unicode escapes to improve readability.
+                body = json.dumps(
+                    obj=obj,
+                    sort_keys=self.format_options['json']['sort_keys'],
+                    ensure_ascii=False,
+                    indent=self.format_options['json']['indent']
+                )
+        return body

httpie/output/processing.py

@@ -0,0 +1,53 @@
+import re
+from typing import Optional, List
+
+from httpie.plugins import ConverterPlugin
+from httpie.plugins.registry import plugin_manager
+from httpie.context import Environment
+
+
+MIME_RE = re.compile(r'^[^/]+/[^/]+$')
+
+
+def is_valid_mime(mime):
+    return mime and MIME_RE.match(mime)
+
+
+class Conversion:
+
+    @staticmethod
+    def get_converter(mime: str) -> Optional[ConverterPlugin]:
+        if is_valid_mime(mime):
+            for converter_class in plugin_manager.get_converters():
+                if converter_class.supports(mime):
+                    return converter_class(mime)
+
+
+class Formatting:
+    """A delegate class that invokes the actual processors."""
+
+    def __init__(self, groups: List[str], env=Environment(), **kwargs):
+        """
+        :param groups: names of processor groups to be applied
+        :param env: Environment
+        :param kwargs: additional keyword arguments for processors
+
+        """
+        available_plugins = plugin_manager.get_formatters_grouped()
+        self.enabled_plugins = []
+        for group in groups:
+            for cls in available_plugins[group]:
+                p = cls(env=env, **kwargs)
+                if p.enabled:
+                    self.enabled_plugins.append(p)
+
+    def format_headers(self, headers: str) -> str:
+        for p in self.enabled_plugins:
+            headers = p.format_headers(headers)
+        return headers
+
+    def format_body(self, content: str, mime: str) -> str:
+        if is_valid_mime(mime):
+            for p in self.enabled_plugins:
+                content = p.format_body(content, mime)
+        return content

httpie/output/streams.py

@@ -0,0 +1,199 @@
+from itertools import chain
+from typing import Callable, Iterable, Union
+
+from httpie.context import Environment
+from httpie.models import HTTPMessage
+from httpie.output.processing import Conversion, Formatting
+
+
+BINARY_SUPPRESSED_NOTICE = (
+    b'\n'
+    b'+-----------------------------------------+\n'
+    b'| NOTE: binary data not shown in terminal |\n'
+    b'+-----------------------------------------+'
+)
+
+
+class DataSuppressedError(Exception):
+    message = None
+
+
+class BinarySuppressedError(DataSuppressedError):
+    """An error indicating that the body is binary and won't be written,
+     e.g., for terminal output)."""
+    message = BINARY_SUPPRESSED_NOTICE
+
+
+class BaseStream:
+    """Base HTTP message output stream class."""
+
+    def __init__(
+        self,
+        msg: HTTPMessage,
+        with_headers=True,
+        with_body=True,
+        on_body_chunk_downloaded: Callable[[bytes], None] = None
+    ):
+        """
+        :param msg: a :class:`models.HTTPMessage` subclass
+        :param with_headers: if `True`, headers will be included
+        :param with_body: if `True`, body will be included
+
+        """
+        assert with_headers or with_body
+        self.msg = msg
+        self.with_headers = with_headers
+        self.with_body = with_body
+        self.on_body_chunk_downloaded = on_body_chunk_downloaded
+
+    def get_headers(self) -> bytes:
+        """Return the headers' bytes."""
+        return self.msg.headers.encode('utf8')
+
+    def iter_body(self) -> Iterable[bytes]:
+        """Return an iterator over the message body."""
+        raise NotImplementedError()
+
+    def __iter__(self) -> Iterable[bytes]:
+        """Return an iterator over `self.msg`."""
+        if self.with_headers:
+            yield self.get_headers()
+            yield b'\r\n\r\n'
+
+        if self.with_body:
+            try:
+                for chunk in self.iter_body():
+                    yield chunk
+                    if self.on_body_chunk_downloaded:
+                        self.on_body_chunk_downloaded(chunk)
+            except DataSuppressedError as e:
+                if self.with_headers:
+                    yield b'\n'
+                yield e.message
+
+
+class RawStream(BaseStream):
+    """The message is streamed in chunks with no processing."""
+
+    CHUNK_SIZE = 1024 * 100
+    CHUNK_SIZE_BY_LINE = 1
+
+    def __init__(self, chunk_size=CHUNK_SIZE, **kwargs):
+        super().__init__(**kwargs)
+        self.chunk_size = chunk_size
+
+    def iter_body(self) -> Iterable[bytes]:
+        return self.msg.iter_body(self.chunk_size)
+
+
+class EncodedStream(BaseStream):
+    """Encoded HTTP message stream.
+
+    The message bytes are converted to an encoding suitable for
+    `self.env.stdout`. Unicode errors are replaced and binary data
+    is suppressed. The body is always streamed by line.
+
+    """
+    CHUNK_SIZE = 1
+
+    def __init__(self, env=Environment(), **kwargs):
+        super().__init__(**kwargs)
+        if env.stdout_isatty:
+            # Use the encoding supported by the terminal.
+            output_encoding = env.stdout_encoding
+        else:
+            # Preserve the message encoding.
+            output_encoding = self.msg.encoding
+        # Default to utf8 when unsure.
+        self.output_encoding = output_encoding or 'utf8'
+
+    def iter_body(self) -> Iterable[bytes]:
+        for line, lf in self.msg.iter_lines(self.CHUNK_SIZE):
+            if b'\0' in line:
+                raise BinarySuppressedError()
+            yield line.decode(self.msg.encoding) \
+                      .encode(self.output_encoding, 'replace') + lf
+
+
+class PrettyStream(EncodedStream):
+    """In addition to :class:`EncodedStream` behaviour, this stream applies
+    content processing.
+
+    Useful for long-lived HTTP responses that stream by lines
+    such as the Twitter streaming API.
+
+    """
+
+    CHUNK_SIZE = 1
+
+    def __init__(
+        self, conversion: Conversion,
+        formatting: Formatting,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.formatting = formatting
+        self.conversion = conversion
+        self.mime = self.msg.content_type.split(';')[0]
+
+    def get_headers(self) -> bytes:
+        return self.formatting.format_headers(
+            self.msg.headers).encode(self.output_encoding)
+
+    def iter_body(self) -> Iterable[bytes]:
+        first_chunk = True
+        iter_lines = self.msg.iter_lines(self.CHUNK_SIZE)
+        for line, lf in iter_lines:
+            if b'\0' in line:
+                if first_chunk:
+                    converter = self.conversion.get_converter(self.mime)
+                    if converter:
+                        body = bytearray()
+                        # noinspection PyAssignmentToLoopOrWithParameter
+                        for line, lf in chain([(line, lf)], iter_lines):
+                            body.extend(line)
+                            body.extend(lf)
+                        self.mime, body = converter.convert(body)
+                        assert isinstance(body, str)
+                        yield self.process_body(body)
+                        return
+                raise BinarySuppressedError()
+            yield self.process_body(line) + lf
+            first_chunk = False
+
+    def process_body(self, chunk: Union[str, bytes]) -> bytes:
+        if not isinstance(chunk, str):
+            # Text when a converter has been used,
+            # otherwise it will always be bytes.
+            chunk = chunk.decode(self.msg.encoding, 'replace')
+        chunk = self.formatting.format_body(content=chunk, mime=self.mime)
+        return chunk.encode(self.output_encoding, 'replace')
+
+
+class BufferedPrettyStream(PrettyStream):
+    """The same as :class:`PrettyStream` except that the body is fully
+    fetched before it's processed.
+
+    Suitable regular HTTP responses.
+
+    """
+
+    CHUNK_SIZE = 1024 * 10
+
+    def iter_body(self) -> Iterable[bytes]:
+        # Read the whole body before prettifying it,
+        # but bail out immediately if the body is binary.
+        converter = None
+        body = bytearray()
+
+        for chunk in self.msg.iter_body(self.CHUNK_SIZE):
+            if not converter and b'\0' in chunk:
+                converter = self.conversion.get_converter(self.mime)
+                if not converter:
+                    raise BinarySuppressedError()
+            body.extend(chunk)
+
+        if converter:
+            self.mime, body = converter.convert(body)
+
+        yield self.process_body(body)

httpie/output/writer.py

@@ -0,0 +1,152 @@
+import argparse
+import errno
+from typing import IO, TextIO, Tuple, Type, Union
+
+import requests
+
+from httpie.context import Environment
+from httpie.models import HTTPRequest, HTTPResponse
+from httpie.output.processing import Conversion, Formatting
+from httpie.output.streams import (
+    BaseStream, BufferedPrettyStream, EncodedStream, PrettyStream, RawStream,
+)
+
+
+def write_message(
+    requests_message: Union[requests.PreparedRequest, requests.Response],
+    env: Environment,
+    args: argparse.Namespace,
+    with_headers=False,
+    with_body=False,
+):
+    if not (with_body or with_headers):
+        return
+    write_stream_kwargs = {
+        'stream': build_output_stream_for_message(
+            args=args,
+            env=env,
+            requests_message=requests_message,
+            with_body=with_body,
+            with_headers=with_headers,
+        ),
+        # NOTE: `env.stdout` will in fact be `stderr` with `--download`
+        'outfile': env.stdout,
+        'flush': env.stdout_isatty or args.stream
+    }
+    try:
+        if env.is_windows and 'colors' in args.prettify:
+            write_stream_with_colors_win_py3(**write_stream_kwargs)
+        else:
+            write_stream(**write_stream_kwargs)
+    except IOError as e:
+        show_traceback = args.debug or args.traceback
+        if not show_traceback and e.errno == errno.EPIPE:
+            # Ignore broken pipes unless --traceback.
+            env.stderr.write('\n')
+        else:
+            raise
+
+
+def write_stream(
+    stream: BaseStream,
+    outfile: Union[IO, TextIO],
+    flush: bool
+):
+    """Write the output stream."""
+    try:
+        # Writing bytes so we use the buffer interface (Python 3).
+        buf = outfile.buffer
+    except AttributeError:
+        buf = outfile
+
+    for chunk in stream:
+        buf.write(chunk)
+        if flush:
+            outfile.flush()
+
+
+def write_stream_with_colors_win_py3(
+    stream: 'BaseStream',
+    outfile: TextIO,
+    flush: bool
+):
+    """Like `write`, but colorized chunks are written as text
+    directly to `outfile` to ensure it gets processed by colorama.
+    Applies only to Windows with Python 3 and colorized terminal output.
+
+    """
+    color = b'\x1b['
+    encoding = outfile.encoding
+    for chunk in stream:
+        if color in chunk:
+            outfile.write(chunk.decode(encoding))
+        else:
+            outfile.buffer.write(chunk)
+        if flush:
+            outfile.flush()
+
+
+def build_output_stream_for_message(
+    args: argparse.Namespace,
+    env: Environment,
+    requests_message: Union[requests.PreparedRequest, requests.Response],
+    with_headers: bool,
+    with_body: bool,
+):
+    stream_class, stream_kwargs = get_stream_type_and_kwargs(
+        env=env,
+        args=args,
+    )
+    message_class = {
+        requests.PreparedRequest: HTTPRequest,
+        requests.Response: HTTPResponse,
+    }[type(requests_message)]
+    yield from stream_class(
+        msg=message_class(requests_message),
+        with_headers=with_headers,
+        with_body=with_body,
+        **stream_kwargs,
+    )
+    if (env.stdout_isatty and with_body
+            and not getattr(requests_message, 'is_body_upload_chunk', False)):
+        # Ensure a blank line after the response body.
+        # For terminal output only.
+        yield b'\n\n'
+
+
+def get_stream_type_and_kwargs(
+    env: Environment,
+    args: argparse.Namespace
+) -> Tuple[Type['BaseStream'], dict]:
+    """Pick the right stream type and kwargs for it based on `env` and `args`.
+
+    """
+    if not env.stdout_isatty and not args.prettify:
+        stream_class = RawStream
+        stream_kwargs = {
+            'chunk_size': (
+                RawStream.CHUNK_SIZE_BY_LINE
+                if args.stream
+                else RawStream.CHUNK_SIZE
+            )
+        }
+    elif args.prettify:
+        stream_class = PrettyStream if args.stream else BufferedPrettyStream
+        stream_kwargs = {
+            'env': env,
+            'conversion': Conversion(),
+            'formatting': Formatting(
+                env=env,
+                groups=args.prettify,
+                color_scheme=args.style,
+                explicit_json=args.json,
+                format_options=args.format_options,
+            )
+        }
+    else:
+        stream_class = EncodedStream
+        stream_kwargs = {
+            'env': env
+        }
+
+    return stream_class, stream_kwargs

httpie/plugins/__init__.py

@@ -0,0 +1,9 @@
+"""
+WARNING: The plugin API is still work in progress and will
+         probably be completely reworked in the future.
+
+"""
+from httpie.plugins.base import (
+    AuthPlugin, FormatterPlugin,
+    ConverterPlugin, TransportPlugin
+)

httpie/plugins/base.py

@@ -0,0 +1,148 @@
+class BasePlugin:
+
+    # The name of the plugin, eg. "My auth".
+    name = None
+
+    # Optional short description. It will be shown in the help
+    # under --auth-type.
+    description = None
+
+    # This be set automatically once the plugin has been loaded.
+    package_name = None
+
+
+class AuthPlugin(BasePlugin):
+    """
+    Base auth plugin class.
+
+    See httpie-ntlm for an example auth plugin:
+
+        <https://github.com/httpie/httpie-ntlm>
+
+    See also `test_auth_plugins.py`
+
+    """
+    # The value that should be passed to --auth-type
+    # to use this auth plugin. Eg. "my-auth"
+    auth_type = None
+
+    # Set to `False` to make it possible to invoke this auth
+    # plugin without requiring the user to specify credentials
+    # through `--auth, -a`.
+    auth_require = True
+
+    # By default the `-a` argument is parsed for `username:password`.
+    # Set this to `False` to disable the parsing and error handling.
+    auth_parse = True
+
+    # Set to `True` to make it possible for this auth
+    # plugin to acquire credentials from the user’s netrc file(s).
+    # It is used as a fallback when the credentials are not provided explicitly
+    # through `--auth, -a`. Enabling this will allow skipping `--auth, -a`
+    # even when `auth_require` is set `True` (provided that netrc provides
+    # credential for a given host).
+    netrc_parse = False
+
+    # If both `auth_parse` and `prompt_password` are set to `True`,
+    # and the value of `-a` lacks the password part,
+    # then the user will be prompted to type the password in.
+    prompt_password = True
+
+    # Will be set to the raw value of `-a` (if provided) before
+    # `get_auth()` gets called. If the credentials came from a netrc file,
+    # then this is `None`.
+    raw_auth = None
+
+    def get_auth(self, username=None, password=None):
+        """
+        If `auth_parse` is set to `True`, then `username`
+        and `password` contain the parsed credentials.
+
+        Use `self.raw_auth` to access the raw value passed through
+        `--auth, -a`.
+
+        Return a ``requests.auth.AuthBase`` subclass instance.
+
+        """
+        raise NotImplementedError()
+
+
+class TransportPlugin(BasePlugin):
+    """
+    Requests transport adapter docs:
+
+        <https://requests.readthedocs.io/en/latest/user/advanced/#transport-adapters>
+
+    See httpie-unixsocket for an example transport plugin:
+
+        <https://github.com/httpie/httpie-unixsocket>
+
+    """
+
+    # The URL prefix the adapter should be mount to.
+    prefix = None
+
+    def get_adapter(self):
+        """
+        Return a ``requests.adapters.BaseAdapter`` subclass instance to be
+        mounted to ``self.prefix``.
+
+        """
+        raise NotImplementedError()
+
+
+class ConverterPlugin(BasePlugin):
+    """
+    Possibly converts response data for prettified terminal display.
+
+    See httpie-msgpack for an example converter plugin:
+
+        <https://github.com/rasky/httpie-msgpack>.
+
+    """
+
+    def __init__(self, mime):
+        self.mime = mime
+
+    def convert(self, content_bytes):
+        raise NotImplementedError
+
+    @classmethod
+    def supports(cls, mime):
+        raise NotImplementedError
+
+
+class FormatterPlugin(BasePlugin):
+    """
+    Possibly formats response body & headers for prettified terminal display.
+
+    """
+    group_name = 'format'
+
+    def __init__(self, **kwargs):
+        """
+        :param env: an class:`Environment` instance
+        :param kwargs: additional keyword argument that some
+                       formatters might require.
+
+        """
+        self.enabled = True
+        self.kwargs = kwargs
+        self.format_options = kwargs['format_options']
+
+    def format_headers(self, headers: str) -> str:
+        """Return processed `headers`
+
+        :param headers: The headers as text.
+
+        """
+        return headers
+
+    def format_body(self, content: str, mime: str) -> str:
+        """Return processed `content`.
+
+        :param mime: E.g., 'application/atom+xml'.
+        :param content: The body content as text
+
+        """
+        return content

httpie/plugins/builtin.py

@@ -0,0 +1,58 @@
+from base64 import b64encode
+
+import requests.auth
+
+from httpie.plugins.base import AuthPlugin
+
+
+# noinspection PyAbstractClass
+class BuiltinAuthPlugin(AuthPlugin):
+    package_name = '(builtin)'
+
+
+class HTTPBasicAuth(requests.auth.HTTPBasicAuth):
+
+    def __call__(
+        self,
+        request: requests.PreparedRequest
+    ) -> requests.PreparedRequest:
+        """
+        Override username/password serialization to allow unicode.
+
+        See https://github.com/jakubroztocil/httpie/issues/212
+
+        """
+        # noinspection PyTypeChecker
+        request.headers['Authorization'] = type(self).make_header(
+            self.username, self.password).encode('latin1')
+        return request
+
+    @staticmethod
+    def make_header(username: str, password: str) -> str:
+        credentials = u'%s:%s' % (username, password)
+        token = b64encode(credentials.encode('utf8')).strip().decode('latin1')
+        return 'Basic %s' % token
+
+
+class BasicAuthPlugin(BuiltinAuthPlugin):
+    name = 'Basic HTTP auth'
+    auth_type = 'basic'
+    netrc_parse = True
+
+    # noinspection PyMethodOverriding
+    def get_auth(self, username: str, password: str) -> HTTPBasicAuth:
+        return HTTPBasicAuth(username, password)
+
+
+class DigestAuthPlugin(BuiltinAuthPlugin):
+    name = 'Digest HTTP auth'
+    auth_type = 'digest'
+    netrc_parse = True
+
+    # noinspection PyMethodOverriding
+    def get_auth(
+        self,
+        username: str,
+        password: str
+    ) -> requests.auth.HTTPDigestAuth:
+        return requests.auth.HTTPDigestAuth(username, password)

httpie/plugins/manager.py

@@ -0,0 +1,69 @@
+from itertools import groupby
+from operator import attrgetter
+from typing import Dict, List, Type
+
+from pkg_resources import iter_entry_points
+
+from httpie.plugins import AuthPlugin, ConverterPlugin, FormatterPlugin
+from httpie.plugins.base import BasePlugin, TransportPlugin
+
+
+ENTRY_POINT_NAMES = [
+    'httpie.plugins.auth.v1',
+    'httpie.plugins.formatter.v1',
+    'httpie.plugins.converter.v1',
+    'httpie.plugins.transport.v1',
+]
+
+
+class PluginManager(list):
+
+    def register(self, *plugins: Type[BasePlugin]):
+        for plugin in plugins:
+            self.append(plugin)
+
+    def unregister(self, plugin: Type[BasePlugin]):
+        self.remove(plugin)
+
+    def filter(self, by_type=Type[BasePlugin]):
+        return [plugin for plugin in self if issubclass(plugin, by_type)]
+
+    def load_installed_plugins(self):
+        for entry_point_name in ENTRY_POINT_NAMES:
+            for entry_point in iter_entry_points(entry_point_name):
+                plugin = entry_point.load()
+                plugin.package_name = entry_point.dist.key
+                self.register(entry_point.load())
+
+    # Auth
+    def get_auth_plugins(self) -> List[Type[AuthPlugin]]:
+        return self.filter(AuthPlugin)
+
+    def get_auth_plugin_mapping(self) -> Dict[str, Type[AuthPlugin]]:
+        return {
+            plugin.auth_type: plugin for plugin in self.get_auth_plugins()
+        }
+
+    def get_auth_plugin(self, auth_type: str) -> Type[AuthPlugin]:
+        return self.get_auth_plugin_mapping()[auth_type]
+
+    # Output processing
+    def get_formatters(self) -> List[Type[FormatterPlugin]]:
+        return self.filter(FormatterPlugin)
+
+    def get_formatters_grouped(self) -> Dict[str, List[Type[FormatterPlugin]]]:
+        return {
+            group_name: list(group)
+            for group_name, group
+            in groupby(self.get_formatters(), key=attrgetter('group_name'))
+        }
+
+    def get_converters(self) -> List[Type[ConverterPlugin]]:
+        return self.filter(ConverterPlugin)
+
+    # Adapters
+    def get_transport_plugins(self) -> List[Type[TransportPlugin]]:
+        return self.filter(TransportPlugin)
+
+    def __repr__(self):
+        return f'<PluginManager: {list(self)}>'

httpie/plugins/registry.py

@@ -0,0 +1,18 @@
+from httpie.plugins.manager import PluginManager
+from httpie.plugins.builtin import BasicAuthPlugin, DigestAuthPlugin
+from httpie.output.formatters.headers import HeadersFormatter
+from httpie.output.formatters.json import JSONFormatter
+from httpie.output.formatters.colors import ColorFormatter
+
+
+plugin_manager = PluginManager()
+
+
+# Register all built-in plugins.
+plugin_manager.register(
+    BasicAuthPlugin,
+    DigestAuthPlugin,
+    HeadersFormatter,
+    JSONFormatter,
+    ColorFormatter,
+)

httpie/sessions.py

@@ -1,127 +1,62 @@
-"""Persistent, JSON-serialized sessions.
+"""
+Persistent, JSON-serialized sessions.
 
 """
-import re
 import os
-import glob
-import errno
-import shutil
+import re
 
-import requests
+from http.cookies import SimpleCookie
+from pathlib import Path
+from typing import Iterable, Optional, Union
+from urllib.parse import urlsplit
+
+from requests.auth import AuthBase
 from requests.cookies import RequestsCookieJar, create_cookie
-from requests.auth import HTTPBasicAuth, HTTPDigestAuth
 
-from .compat import urlsplit
-from .config import BaseConfigDict, DEFAULT_CONFIG_DIR
+from httpie.cli.dicts import RequestHeadersDict
+from httpie.config import BaseConfigDict, DEFAULT_CONFIG_DIR
+from httpie.plugins.registry import plugin_manager
 
 
 SESSIONS_DIR_NAME = 'sessions'
-DEFAULT_SESSIONS_DIR = os.path.join(DEFAULT_CONFIG_DIR, SESSIONS_DIR_NAME)
+DEFAULT_SESSIONS_DIR = DEFAULT_CONFIG_DIR / SESSIONS_DIR_NAME
+VALID_SESSION_NAME_PATTERN = re.compile('^[a-zA-Z0-9_.-]+$')
+# Request headers starting with these prefixes won't be stored in sessions.
+# They are specific to each request.
+# <https://en.wikipedia.org/wiki/List_of_HTTP_header_fields#Requests>
+SESSION_IGNORED_HEADER_PREFIXES = ['Content-', 'If-']
 
 
-def get_response(name, request_kwargs, config_dir, read_only=False):
-    """Like `client.get_response`, but applies permanent
-    aspects of the session to the request.
-
-    """
-    sessions_dir = os.path.join(config_dir, SESSIONS_DIR_NAME)
-    host = Host(
-        root_dir=sessions_dir,
-        name=request_kwargs['headers'].get('Host', None)
-             or urlsplit(request_kwargs['url']).netloc.split('@')[-1]
-    )
-    session = Session(host, name)
-    session.load()
-
-    # Update session headers with the request headers.
-    session['headers'].update(request_kwargs.get('headers', {}))
-    # Use the merged headers for the request
-    request_kwargs['headers'] = session['headers']
-
-    auth = request_kwargs.get('auth', None)
-    if auth:
-        session.auth = auth
-    elif session.auth:
-        request_kwargs['auth'] = session.auth
-
-    requests_session = requests.Session()
-    requests_session.cookies = session.cookies
-
-    try:
-        response = requests_session.request(**request_kwargs)
-    except Exception:
-        raise
+def get_httpie_session(
+    config_dir: Path,
+    session_name: str,
+    host: Optional[str],
+    url: str,
+) -> 'Session':
+    if os.path.sep in session_name:
+        path = os.path.expanduser(session_name)
     else:
-        # Existing sessions with `read_only=True` don't get updated.
-        if session.is_new or not read_only:
-            session.cookies = requests_session.cookies
-            session.save()
-        return response
+        hostname = host or urlsplit(url).netloc.split('@')[-1]
+        if not hostname:
+            # HACK/FIXME: httpie-unixsocket's URLs have no hostname.
+            hostname = 'localhost'
 
-
-class Host(object):
-    """A host is a per-host directory on the disk containing sessions files."""
-
-    VALID_NAME_PATTERN = re.compile('^[a-zA-Z0-9_.:-]+$')
-
-    def __init__(self, name, root_dir=DEFAULT_SESSIONS_DIR):
-        assert self.VALID_NAME_PATTERN.match(name)
-        self.name = name
-        self.root_dir = root_dir
-
-    def __iter__(self):
-        """Return an iterator yielding `Session` instances."""
-        for fn in sorted(glob.glob1(self.path, '*.json')):
-            session_name = os.path.splitext(fn)[0]
-            yield Session(host=self, name=session_name)
-
-    @staticmethod
-    def _quote_name(name):
-        """host:port => host_port"""
-        return name.replace(':', '_')
-
-    @staticmethod
-    def _unquote_name(name):
-        """host_port => host:port"""
-        return re.sub(r'_(\d+)$', r':\1', name)
-
-    @classmethod
-    def all(cls, root_dir=DEFAULT_SESSIONS_DIR):
-        """Return a generator yielding a host at a time."""
-        for name in sorted(glob.glob1(root_dir, '*')):
-            if os.path.isdir(os.path.join(root_dir, name)):
-                yield Host(cls._unquote_name(name), root_dir=root_dir)
-
-    @property
-    def verbose_name(self):
-        return '%s %s' % (self.name, self.path)
-
-    def delete(self):
-        shutil.rmtree(self.path)
-
-    @property
-    def path(self):
-        path = os.path.join(self.root_dir, self._quote_name(self.name))
-        try:
-            os.makedirs(path, mode=0o700)
-        except OSError as e:
-            if e.errno != errno.EEXIST:
-                raise
-        return path
+        # host:port => host_port
+        hostname = hostname.replace(':', '_')
+        path = (
+            config_dir / SESSIONS_DIR_NAME / hostname / f'{session_name}.json'
+        )
+    session = Session(path)
+    session.load()
+    return session
 
 
 class Session(BaseConfigDict):
-
-    help = 'https://github.com/jkbr/httpie#sessions'
+    helpurl = 'https://httpie.org/doc#sessions'
     about = 'HTTPie session file'
 
-    VALID_NAME_PATTERN = re.compile('^[a-zA-Z0-9_.-]+$')
-
-    def __init__(self, host, name, *args, **kwargs):
-        assert self.VALID_NAME_PATTERN.match(name)
-        super(Session, self).__init__(*args, **kwargs)
-        self.host = host
-        self.name = name
+    def __init__(self, path: Union[str, Path]):
+        super().__init__(path=Path(path))
         self['headers'] = {}
         self['cookies'] = {}
         self['auth'] = {
@@ -130,16 +65,42 @@ class Session(BaseConfigDict):
             'password': None
         }
 
-    @property
-    def directory(self):
-        return self.host.path
+    def update_headers(self, request_headers: RequestHeadersDict):
+        """
+        Update the session headers with the request ones while ignoring
+        certain name prefixes.
+
+        """
+        headers = self.headers
+        for name, value in request_headers.items():
+
+            if value is None:
+                continue  # Ignore explicitly unset headers
+
+            value = value.decode('utf8')
+            if name.lower() == 'user-agent' and value.startswith('HTTPie/'):
+                continue
+
+            if name.lower() == 'cookie':
+                for cookie_name, morsel in SimpleCookie(value).items():
+                    self['cookies'][cookie_name] = {'value': morsel.value}
+                del request_headers[name]
+                continue
+
+            for prefix in SESSION_IGNORED_HEADER_PREFIXES:
+                if name.lower().startswith(prefix.lower()):
+                    break
+            else:
+                headers[name] = value
+
+        self['headers'] = dict(headers)
 
     @property
-    def verbose_name(self):
-        return '%s %s %s' % (self.host.name, self.name, self.path)
+    def headers(self) -> RequestHeadersDict:
+        return RequestHeadersDict(self['headers'])
 
     @property
-    def cookies(self):
+    def cookies(self) -> RequestsCookieJar:
         jar = RequestsCookieJar()
         for name, cookie_dict in self['cookies'].items():
             jar.set_cookie(create_cookie(
@@ -148,32 +109,51 @@ class Session(BaseConfigDict):
         return jar
 
     @cookies.setter
-    def cookies(self, jar):
-        # http://docs.python.org/2/library/cookielib.html#cookie-objects
+    def cookies(self, jar: RequestsCookieJar):
+        # <https://docs.python.org/2/library/cookielib.html#cookie-objects>
         stored_attrs = ['value', 'path', 'secure', 'expires']
         self['cookies'] = {}
-        for host in jar._cookies.values():
-            for path in host.values():
-                for name, cookie in path.items():
-                    self['cookies'][name] = dict(
-                        (attname, getattr(cookie, attname))
-                        for attname in stored_attrs
-                    )
+        for cookie in jar:
+            self['cookies'][cookie.name] = {
+                attname: getattr(cookie, attname)
+                for attname in stored_attrs
+            }
 
     @property
-    def auth(self):
+    def auth(self) -> Optional[AuthBase]:
         auth = self.get('auth', None)
         if not auth or not auth['type']:
             return
-        Auth = {'basic': HTTPBasicAuth,
-                'digest': HTTPDigestAuth}[auth['type']]
-        return Auth(auth['username'], auth['password'])
+
+        plugin = plugin_manager.get_auth_plugin(auth['type'])()
+
+        credentials = {'username': None, 'password': None}
+        try:
+            # New style
+            plugin.raw_auth = auth['raw_auth']
+        except KeyError:
+            # Old style
+            credentials = {
+                'username': auth['username'],
+                'password': auth['password'],
+            }
+        else:
+            if plugin.auth_parse:
+                from httpie.cli.argtypes import parse_auth
+                parsed = parse_auth(plugin.raw_auth)
+                credentials = {
+                    'username': parsed.key,
+                    'password': parsed.value,
+                }
+
+        return plugin.get_auth(**credentials)
 
     @auth.setter
-    def auth(self, cred):
-        self['auth'] = {
-            'type': {HTTPBasicAuth: 'basic',
-                     HTTPDigestAuth: 'digest'}[type(cred)],
-            'username': cred.username,
-            'password': cred.password,
-        }
+    def auth(self, auth: dict):
+        assert {'type', 'raw_auth'} == auth.keys()
+        self['auth'] = auth
+
+    def remove_cookies(self, names: Iterable[str]):
+        for name in names:
+            if name in self['cookies']:
+                del self['cookies'][name]

httpie/solarized.py

@@ -1,111 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-    solarized256
-    ------------
-
-    A Pygments style inspired by Solarized's 256 color mode.
-
-    :copyright: (c) 2011 by Hank Gay, (c) 2012 by John Mastro.
-    :license: BSD, see LICENSE for more details.
-"""
-
-from pygments.style import Style
-from pygments.token import Token, Comment, Name, Keyword, Generic, Number, \
-    Operator, String
-
-BASE03  = "#1c1c1c"
-BASE02  = "#262626"
-BASE01  = "#4e4e4e"
-BASE00  = "#585858"
-BASE0   = "#808080"
-BASE1   = "#8a8a8a"
-BASE2   = "#d7d7af"
-BASE3   = "#ffffd7"
-YELLOW  = "#af8700"
-ORANGE  = "#d75f00"
-RED     = "#af0000"
-MAGENTA = "#af005f"
-VIOLET  = "#5f5faf"
-BLUE    = "#0087ff"
-CYAN    = "#00afaf"
-GREEN   = "#5f8700"
-
-
-class Solarized256Style(Style):
-    background_color = BASE03
-    styles = {
-        Keyword: GREEN,
-        Keyword.Constant: ORANGE,
-        Keyword.Declaration: BLUE,
-        Keyword.Namespace: ORANGE,
-        #Keyword.Pseudo
-        Keyword.Reserved: BLUE,
-        Keyword.Type: RED,
-
-        #Name
-        Name.Attribute: BASE1,
-        Name.Builtin: BLUE,
-        Name.Builtin.Pseudo: BLUE,
-        Name.Class: BLUE,
-        Name.Constant: ORANGE,
-        Name.Decorator: BLUE,
-        Name.Entity: ORANGE,
-        Name.Exception: YELLOW,
-        Name.Function: BLUE,
-        #Name.Label
-        #Name.Namespace
-        #Name.Other
-        Name.Tag: BLUE,
-        Name.Variable: BLUE,
-        #Name.Variable.Class
-        #Name.Variable.Global
-        #Name.Variable.Instance
-
-        #Literal
-        #Literal.Date
-        String: CYAN,
-        String.Backtick: BASE01,
-        String.Char: CYAN,
-        String.Doc: CYAN,
-        #String.Double
-        String.Escape: RED,
-        String.Heredoc: CYAN,
-        #String.Interpol
-        #String.Other
-        String.Regex: RED,
-        #String.Single
-        #String.Symbol
-        Number: CYAN,
-        #Number.Float
-        #Number.Hex
-        #Number.Integer
-        #Number.Integer.Long
-        #Number.Oct
-
-        Operator: BASE1,
-        Operator.Word: GREEN,
-
-        #Punctuation: ORANGE,
-
-        Comment: BASE01,
-        #Comment.Multiline
-        Comment.Preproc: GREEN,
-        #Comment.Single
-        Comment.Special: GREEN,
-
-        #Generic
-        Generic.Deleted: CYAN,
-        Generic.Emph: 'italic',
-        Generic.Error: RED,
-        Generic.Heading: ORANGE,
-        Generic.Inserted: GREEN,
-        #Generic.Output
-        #Generic.Prompt
-        Generic.Strong: 'bold',
-        Generic.Subheading: ORANGE,
-        #Generic.Traceback
-
-        Token: BASE1,
-        Token.Other: ORANGE,
-    }

httpie/ssl.py

@@ -0,0 +1,63 @@
+import ssl
+
+from requests.adapters import HTTPAdapter
+# noinspection PyPackageRequirements
+from urllib3.util.ssl_ import (
+    DEFAULT_CIPHERS, create_urllib3_context,
+    resolve_ssl_version,
+)
+
+
+DEFAULT_SSL_CIPHERS = DEFAULT_CIPHERS
+SSL_VERSION_ARG_MAPPING = {
+    'ssl2.3': 'PROTOCOL_SSLv23',
+    'ssl3': 'PROTOCOL_SSLv3',
+    'tls1': 'PROTOCOL_TLSv1',
+    'tls1.1': 'PROTOCOL_TLSv1_1',
+    'tls1.2': 'PROTOCOL_TLSv1_2',
+    'tls1.3': 'PROTOCOL_TLSv1_3',
+}
+AVAILABLE_SSL_VERSION_ARG_MAPPING = {
+    arg: getattr(ssl, constant_name)
+    for arg, constant_name in SSL_VERSION_ARG_MAPPING.items()
+    if hasattr(ssl, constant_name)
+}
+
+
+class HTTPieHTTPSAdapter(HTTPAdapter):
+    def __init__(
+        self,
+        verify: bool,
+        ssl_version: str = None,
+        ciphers: str = None,
+        **kwargs
+    ):
+        self._ssl_context = self._create_ssl_context(
+            verify=verify,
+            ssl_version=ssl_version,
+            ciphers=ciphers,
+        )
+        super().__init__(**kwargs)
+
+    def init_poolmanager(self, *args, **kwargs):
+        kwargs['ssl_context'] = self._ssl_context
+        return super().init_poolmanager(*args, **kwargs)
+
+    def proxy_manager_for(self, *args, **kwargs):
+        kwargs['ssl_context'] = self._ssl_context
+        return super().proxy_manager_for(*args, **kwargs)
+
+    @staticmethod
+    def _create_ssl_context(
+        verify: bool,
+        ssl_version: str = None,
+        ciphers: str = None,
+    ) -> 'ssl.SSLContext':
+        return create_urllib3_context(
+            ciphers=ciphers,
+            ssl_version=resolve_ssl_version(ssl_version),
+            # Since we are using a custom SSL context, we need to pass this
+            # here manually, even though it’s also passed to the connection
+            # in `super().cert_verify()`.
+            cert_reqs=ssl.CERT_REQUIRED if verify else ssl.CERT_NONE
+        )

httpie/status.py

@@ -0,0 +1,40 @@
+from enum import IntEnum, unique
+
+
+@unique
+class ExitStatus(IntEnum):
+    """Program exit status code constants."""
+    SUCCESS = 0
+    ERROR = 1
+    ERROR_TIMEOUT = 2
+
+    # See --check-status
+    ERROR_HTTP_3XX = 3
+    ERROR_HTTP_4XX = 4
+    ERROR_HTTP_5XX = 5
+
+    ERROR_TOO_MANY_REDIRECTS = 6
+    PLUGIN_ERROR = 7
+    # 128+2 SIGINT
+    # <http://www.tldp.org/LDP/abs/html/exitcodes.html>
+    ERROR_CTRL_C = 130
+
+
+def http_status_to_exit_status(http_status: int, follow=False) -> ExitStatus:
+    """
+    Translate HTTP status code to exit status code.
+
+    (Relevant only when invoked with --check-status or --download.)
+
+    """
+    if 300 <= http_status <= 399 and not follow:
+        # Redirect
+        return ExitStatus.ERROR_HTTP_3XX
+    elif 400 <= http_status <= 499:
+        # Client Error
+        return ExitStatus.ERROR_HTTP_4XX
+    elif 500 <= http_status <= 599:
+        # Server Error
+        return ExitStatus.ERROR_HTTP_5XX
+    else:
+        return ExitStatus.SUCCESS

httpie/uploads.py

@@ -0,0 +1,138 @@
+import zlib
+from typing import Callable, IO, Iterable, Tuple, Union
+from urllib.parse import urlencode
+
+import requests
+from requests.utils import super_len
+from requests_toolbelt import MultipartEncoder
+
+from httpie.cli.dicts import MultipartRequestDataDict, RequestDataDict
+
+
+class ChunkedUploadStream:
+    def __init__(self, stream: Iterable, callback: Callable):
+        self.callback = callback
+        self.stream = stream
+
+    def __iter__(self) -> Iterable[Union[str, bytes]]:
+        for chunk in self.stream:
+            self.callback(chunk)
+            yield chunk
+
+
+class ChunkedMultipartUploadStream:
+    chunk_size = 100 * 1024
+
+    def __init__(self, encoder: MultipartEncoder):
+        self.encoder = encoder
+
+    def __iter__(self) -> Iterable[Union[str, bytes]]:
+        while True:
+            chunk = self.encoder.read(self.chunk_size)
+            if not chunk:
+                break
+            yield chunk
+
+
+def prepare_request_body(
+    body: Union[str, bytes, IO, MultipartEncoder, RequestDataDict],
+    body_read_callback: Callable[[bytes], bytes],
+    content_length_header_value: int = None,
+    chunked=False,
+    offline=False,
+) -> Union[str, bytes, IO, MultipartEncoder, ChunkedUploadStream]:
+
+    is_file_like = hasattr(body, 'read')
+
+    if isinstance(body, RequestDataDict):
+        body = urlencode(body, doseq=True)
+
+    if offline:
+        if is_file_like:
+            return body.read()
+        return body
+
+    if not is_file_like:
+        if chunked:
+            body = ChunkedUploadStream(
+                # Pass the entire body as one chunk.
+                stream=(chunk.encode() for chunk in [body]),
+                callback=body_read_callback,
+            )
+    else:
+        # File-like object.
+
+        if not super_len(body):
+            # Zero-length -> assume stdin.
+            if content_length_header_value is None and not chunked:
+                #
+                # Read the whole stdin to determine `Content-Length`.
+                #
+                # TODO: Instead of opt-in --chunked, consider making
+                #   `Transfer-Encoding: chunked` for STDIN opt-out via
+                #   something like --no-chunked.
+                #   This would be backwards-incompatible so wait until v3.0.0.
+                #
+                body = body.read()
+        else:
+            orig_read = body.read
+
+            def new_read(*args):
+                chunk = orig_read(*args)
+                body_read_callback(chunk)
+                return chunk
+
+            body.read = new_read
+
+        if chunked:
+            if isinstance(body, MultipartEncoder):
+                body = ChunkedMultipartUploadStream(
+                    encoder=body,
+                )
+            else:
+                body = ChunkedUploadStream(
+                    stream=body,
+                    callback=body_read_callback,
+                )
+
+    return body
+
+
+def get_multipart_data_and_content_type(
+    data: MultipartRequestDataDict,
+    boundary: str = None,
+    content_type: str = None,
+) -> Tuple[MultipartEncoder, str]:
+    encoder = MultipartEncoder(
+        fields=data.items(),
+        boundary=boundary,
+    )
+    if content_type:
+        content_type = content_type.strip()
+        if 'boundary=' not in content_type:
+            content_type = f'{content_type}; boundary={encoder.boundary_value}'
+    else:
+        content_type = encoder.content_type
+
+    data = encoder
+    return data, content_type
+
+
+def compress_request(
+    request: requests.PreparedRequest,
+    always: bool,
+):
+    deflater = zlib.compressobj()
+    if isinstance(request.body, str):
+        body_bytes = request.body.encode()
+    elif hasattr(request.body, 'read'):
+        body_bytes = request.body.read()
+    else:
+        body_bytes = request.body
+    deflated_data = deflater.compress(body_bytes)
+    deflated_data += deflater.flush()
+    is_economical = len(deflated_data) < len(body_bytes)
+    if is_economical or always:
+        request.body = deflated_data
+        request.headers['Content-Encoding'] = 'deflate'
+        request.headers['Content-Length'] = str(len(deflated_data))

httpie/utils.py

@@ -0,0 +1,119 @@
+from __future__ import division
+
+import json
+import mimetypes
+import time
+from collections import OrderedDict
+from http.cookiejar import parse_ns_headers
+from pprint import pformat
+from typing import List, Optional, Tuple
+
+import requests.auth
+
+
+def load_json_preserve_order(s):
+    return json.loads(s, object_pairs_hook=OrderedDict)
+
+
+def repr_dict(d: dict) -> str:
+    return pformat(d)
+
+
+def humanize_bytes(n, precision=2):
+    # Author: Doug Latornell
+    # Licence: MIT
+    # URL: https://code.activestate.com/recipes/577081/
+    """Return a humanized string representation of a number of bytes.
+
+    Assumes `from __future__ import division`.
+
+    >>> humanize_bytes(1)
+    '1 B'
+    >>> humanize_bytes(1024, precision=1)
+    '1.0 kB'
+    >>> humanize_bytes(1024 * 123, precision=1)
+    '123.0 kB'
+    >>> humanize_bytes(1024 * 12342, precision=1)
+    '12.1 MB'
+    >>> humanize_bytes(1024 * 12342, precision=2)
+    '12.05 MB'
+    >>> humanize_bytes(1024 * 1234, precision=2)
+    '1.21 MB'
+    >>> humanize_bytes(1024 * 1234 * 1111, precision=2)
+    '1.31 GB'
+    >>> humanize_bytes(1024 * 1234 * 1111, precision=1)
+    '1.3 GB'
+
+    """
+    abbrevs = [
+        (1 << 50, 'PB'),
+        (1 << 40, 'TB'),
+        (1 << 30, 'GB'),
+        (1 << 20, 'MB'),
+        (1 << 10, 'kB'),
+        (1, 'B')
+    ]
+
+    if n == 1:
+        return '1 B'
+
+    for factor, suffix in abbrevs:
+        if n >= factor:
+            break
+
+    # noinspection PyUnboundLocalVariable
+    return '%.*f %s' % (precision, n / factor, suffix)
+
+
+class ExplicitNullAuth(requests.auth.AuthBase):
+    """Forces requests to ignore the ``.netrc``.
+    <https://github.com/psf/requests/issues/2773#issuecomment-174312831>
+    """
+
+    def __call__(self, r):
+        return r
+
+
+def get_content_type(filename):
+    """
+    Return the content type for ``filename`` in format appropriate
+    for Content-Type headers, or ``None`` if the file type is unknown
+    to ``mimetypes``.
+
+    """
+    mime, encoding = mimetypes.guess_type(filename, strict=False)
+    if mime:
+        content_type = mime
+        if encoding:
+            content_type = '%s; charset=%s' % (mime, encoding)
+        return content_type
+
+
+def get_expired_cookies(
+    headers: List[Tuple[str, str]],
+    now: float = None
+) -> List[dict]:
+
+    now = now or time.time()
+
+    def is_expired(expires: Optional[float]) -> bool:
+        return expires is not None and expires <= now
+
+    attr_sets: List[Tuple[str, str]] = parse_ns_headers(
+        value for name, value in headers
+        if name.lower() == 'set-cookie'
+    )
+    cookies = [
+        # The first attr name is the cookie name.
+        dict(attrs[1:], name=attrs[0][0])
+        for attrs in attr_sets
+    ]
+
+    return [
+        {
+            'name': cookie['name'],
+            'path': cookie.get('path', '/')
+        }
+        for cookie in cookies
+        if is_expired(expires=cookie.get('expires'))
+    ]

requirements-dev.txt

@@ -0,0 +1,8 @@
+mock
+pytest
+pytest-cov
+pytest-httpbin>=0.0.6
+docutils
+wheel
+pycodestyle
+twine

requirements.txt

@@ -1 +0,0 @@
-#

setup.cfg

@@ -0,0 +1,19 @@
+[wheel]
+
+
+[tool:pytest]
+# <https://docs.pytest.org/en/latest/customize.html>
+norecursedirs = tests/fixtures
+addopts = --tb=native
+
+
+[pycodestyle]
+# <http://pycodestyle.pycqa.org/en/latest/intro.html#configuration>
+
+exclude = .git,.idea,__pycache__,build,dist,.pytest_cache,*.egg-info
+
+# <http://pycodestyle.pycqa.org/en/latest/intro.html#error-codes>
+# E241 - multiple spaces after ‘,’
+# E501 - line too long
+# W503 - line break before binary operator
+ignore = E241,E501,W503

setup.py

@@ -1,35 +1,71 @@
-import os
+# This is purely the result of trial and error.
+
 import sys
-import re
 import codecs
-from setuptools import setup
+
+from setuptools import setup, find_packages
+from setuptools.command.test import test as TestCommand
+
 import httpie
 
 
-if sys.argv[-1] == 'test':
-    status = os.system('python tests/tests.py')
-    sys.exit(1 if status > 127 else status)
+class PyTest(TestCommand):
+    """
+    Running `$ python setup.py test' simply installs minimal requirements
+    and runs the tests with no fancy stuff like parallel execution.
+
+    """
+    def finalize_options(self):
+        TestCommand.finalize_options(self)
+        self.test_args = [
+            '--doctest-modules',
+            '--verbose',
+            './httpie',
+            './tests',
+        ]
+        self.test_suite = True
+
+    def run_tests(self):
+        import pytest
+        sys.exit(pytest.main(self.test_args))
 
 
-requirements = [
-    'requests>=1.0.4',
-    'Pygments>=1.5'
+tests_require = [
+    'pytest-httpbin',
+    'pytest',
+    'mock',
 ]
-if sys.version_info[:2] in ((2, 6), (3, 1)):
-    # argparse has been added in Python 3.2 / 2.7
-    requirements.append('argparse>=1.2.1')
-if 'win32' in str(sys.platform).lower():
-    # Terminal colors for Windows
-    requirements.append('colorama>=0.2.4')
+
+
+install_requires = [
+    'requests[socks]>=2.22.0',
+    'Pygments>=2.5.2',
+    'requests-toolbelt>=0.9.1',
+]
+install_requires_win_only = [
+    'colorama>=0.2.4',
+]
+
+# Conditional dependencies:
+
+# sdist
+if 'bdist_wheel' not in sys.argv:
+
+    if 'win32' in str(sys.platform).lower():
+        # Terminal colors for Windows
+        install_requires.extend(install_requires_win_only)
+
+
+# bdist_wheel
+extras_require = {
+    # https://wheel.readthedocs.io/en/latest/#defining-conditional-dependencies
+    ':sys_platform == "win32"': install_requires_win_only,
+}
 
 
 def long_description():
-    """Pre-process the README so that PyPi can render it properly."""
     with codecs.open('README.rst', encoding='utf8') as f:
-        rst = f.read()
-    code_block = '(:\n\n)?\.\. code-block::.*'
-    rst = re.sub(code_block, '::', rst)
-    return rst
+        return f.read()
 
 
 setup(
@@ -37,25 +73,27 @@ setup(
     version=httpie.__version__,
     description=httpie.__doc__.strip(),
     long_description=long_description(),
-    url='http://httpie.org/',
-    download_url='https://github.com/jkbr/httpie',
+    url='https://httpie.org/',
+    download_url=f'https://github.com/httpie/httpie/archive/{httpie.__version__}.tar.gz',
     author=httpie.__author__,
-    author_email='jakub@roztocil.name',
+    author_email='jakub@roztocil.co',
     license=httpie.__licence__,
-    packages=['httpie'],
+    packages=find_packages(),
     entry_points={
         'console_scripts': [
             'http = httpie.__main__:main',
+            'https = httpie.__main__:main',
         ],
     },
-    install_requires=requirements,
+    python_requires='>=3.6',
+    extras_require=extras_require,
+    install_requires=install_requires,
+    tests_require=tests_require,
+    cmdclass={'test': PyTest},
     classifiers=[
         'Development Status :: 5 - Production/Stable',
         'Programming Language :: Python',
-        'Programming Language :: Python :: 2.6',
-        'Programming Language :: Python :: 2.7',
-        'Programming Language :: Python :: 3.1',
-        'Programming Language :: Python :: 3.2',
+        'Programming Language :: Python :: 3 :: Only',
         'Environment :: Console',
         'Intended Audience :: Developers',
         'Intended Audience :: System Administrators',
@@ -67,4 +105,11 @@ setup(
         'Topic :: Text Processing',
         'Topic :: Utilities'
     ],
+    project_urls={
+        'GitHub': 'https://github.com/httpie/httpie',
+        'Twitter': 'https://twitter.com/httpie',
+        'Documentation': 'https://httpie.org/docs',
+        'Online Demo': 'https://httpie.org/run',
+        'Donate': 'https://httpie.org/donate',
+    },
 )

tests/README.rst

@@ -0,0 +1,8 @@
+HTTPie Test Suite
+=================
+
+
+Please see `CONTRIBUTING`_.
+
+
+.. _CONTRIBUTING: https://github.com/jakubroztocil/httpie/blob/master/CONTRIBUTING.rst

tests/client_certs/client.crt

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIUNMIIO7cG2Lkx+qo0Z43k4+voT4swDQYJKoZIhvcNAQEN
+BQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0yMDA3MDQxMDE5NDBaFw0yMTA3
+MDQxMDE5NDBaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw
+HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQCpnv/bnF8qkRoFu2M/+btxR5kRDAMqvbBivG2F4Uop
+37mxwW0YJFOiMtzCN76w8JgEZrTeH3zG0fNNdIKIKjjwf+8j3KSbQi60oDOelkL5
+34Yt1o+lW9ricKQCsVl/XkYHh4RPnzNE8XRZmcZtL/6+1vVjTlxe6iW1Q0tzU2l3
+RHPhHbmsVclwFOd/eE+D6WB5tb6SVvhDyOfLdZwxWWpgARx6aboR/+/CKazE0wt4
+IJtTpe3M7IHt3i/8EkCZyFNdV+pQ8qz3PIOKBQws8aCpuQ+IHnvq4wSiyUV6eEaU
+bfOguWHGKlyVuN9AIiNl8A4xlU6QHKwzisTuRywschlvT8LaK1WGk+BNGBcidogh
+yp73KrDpiUd+Udv3TPDg5Q7pE6LT+sZxFrCidvZEZ1YdBDfXUhOaCTmtlFFYJiMT
+2+FnPQCfFv53D79llGaovE7t6KBf+qYRpIkSDoYhSSZ5GhFGTVsgQERYG39MSnbz
+4b1CQtg7Q8e9DJq8d/ChKUCfymJ+HSQIXEMu1FXrlEbEoyGvRyvA5cnUHjvY7GPY
+2HGHHaTFhiB9qRQhD3TdK4G6iIHF9tuxi2V+7waYp7q9N8KHfZRhIZbGSWQlaM9f
+njAUy8NAX6W4cL/ZpDf8PpVeMhLolvO8D8qCNZyWD+x5HtqDfqFkFPvr2vOSxZ+v
+6wIDAQABo1MwUTAdBgNVHQ4EFgQUkJwSpoGIxHUaArfJrX602HdHUWcwHwYDVR0j
+BBgwFoAUkJwSpoGIxHUaArfJrX602HdHUWcwDwYDVR0TAQH/BAUwAwEB/zANBgkq
+hkiG9w0BAQ0FAAOCAgEAqDuULnNBNJsydUXDyGTzCrXjJuqhuOhi1eALyCLwuT+F
++/l7hOgdKWn4KJF4vcfNObcWh7sJ+iIcXEOYKaL3dPW9nqj+oCoPBKNAX+u3ZKXy
+I4O5wVAd3X0beh1ba69nOfdn9PMlVEB80TzTda0My9+tI5SD84OXUc7AWQXnh5Sb
+tHkul7cKcBA7/phnlC83qa6WoMlmNfqo8s2u+quDkhshKdrLFGGBI17gUQH3GbHN
+WBymHi/BCCIKYJB9+vt+M5L5C8FtNCMrCwTGtIOgC9IMre4wF2gODbjuRtkO2w6k
+sXOtKweCdgMd2H3SwE4txEU2hUHE1IYPYnG1fg0YwYfKfbTLZQtn7xgEK93+nkp8
+ufnnHgUxd//+pFPkbEOTnShuepl7g45qOBGUX4fBh78EVeL7NIZ9F8dHGsawD/CT
+/tATlH9gQ+JRvXCNCKO8jNgeu3v2gVw+haXP1d4F7NysVIr4A5LiFufJk5Zyizcm
+WyjgfI99CnEwvqzv4yMQCoHAOK3awhH7uR+QHhCpG9D91PlzdJu7yP7O7zQaKobg
+YTqMoMkYr63WbMrH21Tokoc/6CBPAAp3g8rC/E024SquJE7OUG0If5JkvlfJU5EP
+K+e7hFNoD4uc+0cgAccpEb9hCc0oPfC+3WM5poVBKSnukfs4KyqcVIt4ZaNoYic=
+-----END CERTIFICATE-----

tests/client_certs/client.key

@@ -0,0 +1,51 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIJKQIBAAKCAgEAqZ7/25xfKpEaBbtjP/m7cUeZEQwDKr2wYrxtheFKKd+5scFt
+GCRTojLcwje+sPCYBGa03h98xtHzTXSCiCo48H/vI9ykm0IutKAznpZC+d+GLdaP
+pVva4nCkArFZf15GB4eET58zRPF0WZnGbS/+vtb1Y05cXuoltUNLc1Npd0Rz4R25
+rFXJcBTnf3hPg+lgebW+klb4Q8jny3WcMVlqYAEcemm6Ef/vwimsxNMLeCCbU6Xt
+zOyB7d4v/BJAmchTXVfqUPKs9zyDigUMLPGgqbkPiB576uMEoslFenhGlG3zoLlh
+xipclbjfQCIjZfAOMZVOkBysM4rE7kcsLHIZb0/C2itVhpPgTRgXInaIIcqe9yqw
+6YlHflHb90zw4OUO6ROi0/rGcRawonb2RGdWHQQ311ITmgk5rZRRWCYjE9vhZz0A
+nxb+dw+/ZZRmqLxO7eigX/qmEaSJEg6GIUkmeRoRRk1bIEBEWBt/TEp28+G9QkLY
+O0PHvQyavHfwoSlAn8pifh0kCFxDLtRV65RGxKMhr0crwOXJ1B472Oxj2Nhxhx2k
+xYYgfakUIQ903SuBuoiBxfbbsYtlfu8GmKe6vTfCh32UYSGWxklkJWjPX54wFMvD
+QF+luHC/2aQ3/D6VXjIS6JbzvA/KgjWclg/seR7ag36hZBT769rzksWfr+sCAwEA
+AQKCAgBmZ1W0si1KN5vsRftfjle5xi4E+qmWzjqFAZllsGPj7+veAxbn8laDoA1j
+O+BmVnqQfalISN498lbfNi3wIv2JRNONZRIDoesspWNEpRb+YBJT7it++3ukJbj+
+3y9XFAVXWlto7oY3Y0aJKauAE+/KK2CueYqOyvHFA0Gz+HG9zZfgGuATyR76CcTR
+UkM/MlBKao0JMHRmCA7Y6MJJkOAF4eXdiaMKZufK4vopQfi0p4re71gn1cmDYBa8
+KhDSRvz9Z6xQ/pGqGeCYHQACykXi8ZUM6sqJPlF4LedCTwbdaZwiNolu5/hJc/lk
+cLfKPSl0id2KZ6UW4PqPmGx00NXFP/XcCxzzht8ejrI1GY9LXR6fKpmoYZvUoXba
+SK58l+OcAaxJ7JoTCvH2adas5mhNGyHTTghceNlFPuT+LC7nNq6rJD0QLouDQMr5
+0my2lJtDiafa+Z3aGt759vkTT7k4wnfWNkjZJDIVf6UkAoMFtN5nOgR36OaDLegA
+7udascC3hKRUi2BIlc713hl2dlcPVMcCQArpvbwgwPFXiZO9PW+Qc7IWogHqWNWY
+Ms9JsDcAE5Q5PRlAA8QSveSyl3QNJpeHT9PVx159a28E8xEWCs9nfpI/jXfYxFnr
+dfS7gn8XW1WNUJvtHsKIhdSRD/4ks6VRPm6KMskR+j+zpTbmcQKCAQEA3CvDiT/E
+oD2VK9rE0KNDZBljED2p7IVE+zED5olGPUGC3F+WiEl9ldd6DKL6K0Xv/zAEv7Nt
+hHJ4m3B8siOQf2wzrX6JTvqDhBnrYjsD3VU7Zpys4ZjMOAp/aIM124ZRDECe2do3
+yzfV+oR0qw9KmyywjMwPa/8LL9d+kwYSQX6Y2hy+5TquDghKCmQzBw0iCDlmWfNP
+jqfztSc1oBPcij+X98h3EI3Ai7R+hlolWlowXy0qBY8qCWegbguRDFkDhTXDCPwW
+RMiQobI3xWfhZybSohx42/HUYMi5Uis++CV3XeE/aRdLw/O3gHTz5n9Z3v0i0Xnd
+KIWxpCKzLzLAVwKCAQEAxTlZHVlNaVz8fsSajAyq3n4LnOxGEwhYspzY7U2tHnbr
+U1QXTlvGN97u9hMdHgvvPu7OULfeJM0EPNBdQC2B2Y2vkAZBcdw2cgXdzVksv+gO
+//ryo37xBZXY46prGyPZCrfrrBXHNOHlxY1AklQUu8PnNKU+Z02hirMtY6pm/WyI
+2fbUJRqQu3nTMiuqFeee+5vaKbWXPRWKjpF/KZxoA4YSymGhG+fVIJVKxWjz1ns/
+0Kkx/a4D3xWZO+vY9LE24PZzygUfr3/ZsCe8N+UpvZ60h7eJT9DJB1ETgqPFL8zr
+EhGxoNDLRpm0b1JELAuclCHuHdqQ/uTJB2DjSFpAjQKCAQEAxmNU3R4toan7+Tk2
+cT07oz3Q6rh1nd70KlefSSLWvKmELeif7owx8kvn+Oz9+PIa8FmnXcli3J59GKsC
+YU30jSzFYAaN2TGYQfdNBwVgVRbQ4IQ6r0kMc07aQSVB6V4dN6oeuPSNo7rbP9IM
+gnrT4gEh0KyrFMgKn4BQ2E/3MTbOqnKOfGUkoxZLCRQCes8VpE18cX7xZ/zkd44u
+HuDmr1fgKnBjAPKJ1hi8jXk7ATAVOB2tKLc4zKKoh6A6geLPbj/kTvs/YZlL4beB
+04noLBdqYpK/QIimstMLUgQPyG+SIHCvv5UzOw0ng0Ne5opIQ8rajeB+LF5TlC+E
+P/o+HwKCAQAurZcI2jT3JfngqvmFAg6C4EQxXL5tDMGpbHPvHj5GApFJxJJLim8M
+lCfsd7Ohg+OY+n48HnhmL1u8ZPhdEygzbFRL+x8MKrl8HSVUz7FGrk62iRdaWNYE
+o2WU5KW6464f2k3eCb1/J6PxMLBCscHCeuhCzoVJf9cm86dfeloryr9NDx1Attvg
+c0HoEuuLialYFZf53S+xVmLXwVneaFU52EakPZ0a9LC9qHfs5x0m+z6sTQ824jOq
+XftJclWD/FlnvwzCmJnaOKE2DwF+HS/W4DQMFwVZramWoLrEZaxq1s4gFa37yM8D
+o6dP3aGi5xClAq7PxAYjPdTSeTzxx+KVAoIBAQDGwk1/sJW99Oif+7RXvV99l+BL
+1R0BI1Dgc+aXkXSX4OeWJdLdiGLztrJ/lEzesKEdVHmG+wamexaxWzYgUeKklcAA
+IPrEawh3qB9gmlWei4BrK+e0cGjPZwq5bQi7gkpsMdxlHYkCmO12DzZ7/4CaGqET
++Az0Xa7wjlRbSv62HvKbCm1yMizs8l9k3E8vMo9vU1soyEvR3r/aHzo7KyiXJaio
+ioppLcx/FVQCkaFQ1/H4dBZCSxviJxQmnOWlTkJT1mH44GLQnv21UsEWUrpz13VK
+8Dp0zWwNtSKoEQ6YJYl1Nwt04OhUrxG5fStSOpRiQ2r8bUAM0d4qDSjV92Yf
+-----END RSA PRIVATE KEY-----

tests/client_certs/client.pem

@@ -0,0 +1,82 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIUNMIIO7cG2Lkx+qo0Z43k4+voT4swDQYJKoZIhvcNAQEN
+BQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0yMDA3MDQxMDE5NDBaFw0yMTA3
+MDQxMDE5NDBaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw
+HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQCpnv/bnF8qkRoFu2M/+btxR5kRDAMqvbBivG2F4Uop
+37mxwW0YJFOiMtzCN76w8JgEZrTeH3zG0fNNdIKIKjjwf+8j3KSbQi60oDOelkL5
+34Yt1o+lW9ricKQCsVl/XkYHh4RPnzNE8XRZmcZtL/6+1vVjTlxe6iW1Q0tzU2l3
+RHPhHbmsVclwFOd/eE+D6WB5tb6SVvhDyOfLdZwxWWpgARx6aboR/+/CKazE0wt4
+IJtTpe3M7IHt3i/8EkCZyFNdV+pQ8qz3PIOKBQws8aCpuQ+IHnvq4wSiyUV6eEaU
+bfOguWHGKlyVuN9AIiNl8A4xlU6QHKwzisTuRywschlvT8LaK1WGk+BNGBcidogh
+yp73KrDpiUd+Udv3TPDg5Q7pE6LT+sZxFrCidvZEZ1YdBDfXUhOaCTmtlFFYJiMT
+2+FnPQCfFv53D79llGaovE7t6KBf+qYRpIkSDoYhSSZ5GhFGTVsgQERYG39MSnbz
+4b1CQtg7Q8e9DJq8d/ChKUCfymJ+HSQIXEMu1FXrlEbEoyGvRyvA5cnUHjvY7GPY
+2HGHHaTFhiB9qRQhD3TdK4G6iIHF9tuxi2V+7waYp7q9N8KHfZRhIZbGSWQlaM9f
+njAUy8NAX6W4cL/ZpDf8PpVeMhLolvO8D8qCNZyWD+x5HtqDfqFkFPvr2vOSxZ+v
+6wIDAQABo1MwUTAdBgNVHQ4EFgQUkJwSpoGIxHUaArfJrX602HdHUWcwHwYDVR0j
+BBgwFoAUkJwSpoGIxHUaArfJrX602HdHUWcwDwYDVR0TAQH/BAUwAwEB/zANBgkq
+hkiG9w0BAQ0FAAOCAgEAqDuULnNBNJsydUXDyGTzCrXjJuqhuOhi1eALyCLwuT+F
++/l7hOgdKWn4KJF4vcfNObcWh7sJ+iIcXEOYKaL3dPW9nqj+oCoPBKNAX+u3ZKXy
+I4O5wVAd3X0beh1ba69nOfdn9PMlVEB80TzTda0My9+tI5SD84OXUc7AWQXnh5Sb
+tHkul7cKcBA7/phnlC83qa6WoMlmNfqo8s2u+quDkhshKdrLFGGBI17gUQH3GbHN
+WBymHi/BCCIKYJB9+vt+M5L5C8FtNCMrCwTGtIOgC9IMre4wF2gODbjuRtkO2w6k
+sXOtKweCdgMd2H3SwE4txEU2hUHE1IYPYnG1fg0YwYfKfbTLZQtn7xgEK93+nkp8
+ufnnHgUxd//+pFPkbEOTnShuepl7g45qOBGUX4fBh78EVeL7NIZ9F8dHGsawD/CT
+/tATlH9gQ+JRvXCNCKO8jNgeu3v2gVw+haXP1d4F7NysVIr4A5LiFufJk5Zyizcm
+WyjgfI99CnEwvqzv4yMQCoHAOK3awhH7uR+QHhCpG9D91PlzdJu7yP7O7zQaKobg
+YTqMoMkYr63WbMrH21Tokoc/6CBPAAp3g8rC/E024SquJE7OUG0If5JkvlfJU5EP
+K+e7hFNoD4uc+0cgAccpEb9hCc0oPfC+3WM5poVBKSnukfs4KyqcVIt4ZaNoYic=
+-----END CERTIFICATE-----
+-----BEGIN RSA PRIVATE KEY-----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-----END RSA PRIVATE KEY-----

tests/conftest.py

@@ -0,0 +1,24 @@
+import pytest
+from pytest_httpbin import certs
+
+
+@pytest.fixture(scope='function', autouse=True)
+def httpbin_add_ca_bundle(monkeypatch):
+    """
+    Make pytest-httpbin's CA trusted by default.
+
+    (Same as `httpbin_ca_bundle`, just auto-used.).
+
+    """
+    monkeypatch.setenv('REQUESTS_CA_BUNDLE', certs.where())
+
+
+@pytest.fixture(scope='function')
+def httpbin_secure_untrusted(monkeypatch, httpbin_secure):
+    """
+    Like the `httpbin_secure` fixture, but without the
+    make-CA-trusted-by-default.
+
+    """
+    monkeypatch.delenv('REQUESTS_CA_BUNDLE')
+    return httpbin_secure

tests/fixtures/__init__.py

@@ -0,0 +1,31 @@
+"""Test data"""
+from pathlib import Path
+
+
+def patharg(path):
+    """
+    Back slashes need to be escaped in ITEM args,
+    even in Windows paths.
+
+    """
+    return str(path).replace('\\', '\\\\\\')
+
+
+FIXTURES_ROOT = Path(__file__).parent
+FILE_PATH = FIXTURES_ROOT / 'test.txt'
+JSON_FILE_PATH = FIXTURES_ROOT / 'test.json'
+BIN_FILE_PATH = FIXTURES_ROOT / 'test.bin'
+
+FILE_PATH_ARG = patharg(FILE_PATH)
+BIN_FILE_PATH_ARG = patharg(BIN_FILE_PATH)
+JSON_FILE_PATH_ARG = patharg(JSON_FILE_PATH)
+
+# Strip because we don't want new lines in the data so that we can
+# easily count occurrences also when embedded in JSON (where the new
+# line would be escaped).
+FILE_CONTENT = FILE_PATH.read_text('utf8').strip()
+
+
+JSON_FILE_CONTENT = JSON_FILE_PATH.read_text('utf8')
+BIN_FILE_CONTENT = BIN_FILE_PATH.read_bytes()
+UNICODE = FILE_CONTENT

tests/fixtures/file.txt

@@ -1 +0,0 @@
-__test_file_content__

tests/fixtures/file2.txt

@@ -1 +0,0 @@
-__test_file_content__

tests/fixtures/test.json

@@ -0,0 +1,4 @@
+{
+    "name": "Jakub Roztočil",
+    "unicode": "χρυσαφὶ 太陽 เลิศ ♜♞♝♛♚♝♞♜ оживлённым तान्यहानि 有朋"
+}

tests/fixtures/test.txt

@@ -0,0 +1 @@
+[one line of UTF8-encoded unicode text] χρυσαφὶ 太陽 เลิศ ♜♞♝♛♚♝♞♜ оживлённым तान्यहानि 有朋 ஸ்றீனிவாஸ ٱلرَّحْمـَبنِ

tests/test_auth.py

@@ -0,0 +1,142 @@
+"""HTTP authentication-related tests."""
+import mock
+import pytest
+
+from httpie.plugins.builtin import HTTPBasicAuth
+from httpie.status import ExitStatus
+from httpie.utils import ExplicitNullAuth
+from utils import http, add_auth, HTTP_OK, MockEnvironment
+import httpie.cli.constants
+import httpie.cli.definition
+
+
+def test_basic_auth(httpbin_both):
+    r = http('--auth=user:password',
+             'GET', httpbin_both + '/basic-auth/user/password')
+    assert HTTP_OK in r
+    assert r.json == {'authenticated': True, 'user': 'user'}
+
+
+@pytest.mark.parametrize('argument_name', ['--auth-type', '-A'])
+def test_digest_auth(httpbin_both, argument_name):
+    r = http(argument_name + '=digest', '--auth=user:password',
+             'GET', httpbin_both.url + '/digest-auth/auth/user/password')
+    assert HTTP_OK in r
+    assert r.json == {'authenticated': True, 'user': 'user'}
+
+
+@mock.patch('httpie.cli.argtypes.AuthCredentials._getpass',
+            new=lambda self, prompt: 'password')
+def test_password_prompt(httpbin):
+    r = http('--auth', 'user',
+             'GET', httpbin.url + '/basic-auth/user/password')
+    assert HTTP_OK in r
+    assert r.json == {'authenticated': True, 'user': 'user'}
+
+
+def test_credentials_in_url(httpbin_both):
+    url = add_auth(httpbin_both.url + '/basic-auth/user/password',
+                   auth='user:password')
+    r = http('GET', url)
+    assert HTTP_OK in r
+    assert r.json == {'authenticated': True, 'user': 'user'}
+
+
+def test_credentials_in_url_auth_flag_has_priority(httpbin_both):
+    """When credentials are passed in URL and via -a at the same time,
+     then the ones from -a are used."""
+    url = add_auth(httpbin_both.url + '/basic-auth/user/password',
+                   auth='user:wrong')
+    r = http('--auth=user:password', 'GET', url)
+    assert HTTP_OK in r
+    assert r.json == {'authenticated': True, 'user': 'user'}
+
+
+@pytest.mark.parametrize('url', [
+    'username@example.org',
+    'username:@example.org',
+])
+def test_only_username_in_url(url):
+    """
+    https://github.com/jakubroztocil/httpie/issues/242
+
+    """
+    args = httpie.cli.definition.parser.parse_args(args=[url], env=MockEnvironment())
+    assert args.auth
+    assert args.auth.username == 'username'
+    assert args.auth.password == ''
+
+
+def test_missing_auth(httpbin):
+    r = http(
+        '--auth-type=basic',
+        'GET',
+        httpbin + '/basic-auth/user/password',
+        tolerate_error_exit_status=True
+    )
+    assert HTTP_OK not in r
+    assert '--auth required' in r.stderr
+
+
+def test_netrc(httpbin_both):
+    # This one gets handled by requests (no --auth, --auth-type present),
+    # that’s why we patch inside `requests.sessions`.
+    with mock.patch('requests.sessions.get_netrc_auth') as get_netrc_auth:
+        get_netrc_auth.return_value = ('httpie', 'password')
+        r = http(httpbin_both + '/basic-auth/httpie/password')
+        assert get_netrc_auth.call_count == 1
+        assert HTTP_OK in r
+
+
+def test_ignore_netrc(httpbin_both):
+    with mock.patch('httpie.cli.argparser.get_netrc_auth') as get_netrc_auth:
+        get_netrc_auth.return_value = ('httpie', 'password')
+        r = http('--ignore-netrc', httpbin_both + '/basic-auth/httpie/password')
+        assert get_netrc_auth.call_count == 0
+        assert 'HTTP/1.1 401 UNAUTHORIZED' in r
+
+
+def test_ignore_netrc_together_with_auth():
+    args = httpie.cli.definition.parser.parse_args(
+        args=['--ignore-netrc', '--auth=username:password', 'example.org'],
+        env=MockEnvironment(),
+    )
+    assert isinstance(args.auth, HTTPBasicAuth)
+
+
+def test_ignore_netrc_with_auth_type_resulting_in_missing_auth(httpbin):
+    with mock.patch('httpie.cli.argparser.get_netrc_auth') as get_netrc_auth:
+        get_netrc_auth.return_value = ('httpie', 'password')
+        r = http(
+            '--ignore-netrc',
+            '--auth-type=basic',
+            httpbin + '/basic-auth/httpie/password',
+            tolerate_error_exit_status=True,
+        )
+    assert get_netrc_auth.call_count == 0
+    assert r.exit_status == ExitStatus.ERROR
+    assert '--auth required' in r.stderr
+
+
+@pytest.mark.parametrize(
+    argnames=['auth_type', 'endpoint'],
+    argvalues=[
+        ('basic', '/basic-auth/httpie/password'),
+        ('digest', '/digest-auth/auth/httpie/password'),
+    ],
+)
+def test_auth_plugin_netrc_parse(auth_type, endpoint, httpbin):
+    # Test
+    with mock.patch('httpie.cli.argparser.get_netrc_auth') as get_netrc_auth:
+        get_netrc_auth.return_value = ('httpie', 'password')
+        r = http('--auth-type', auth_type, httpbin + endpoint)
+    assert get_netrc_auth.call_count == 1
+    assert HTTP_OK in r
+
+
+def test_ignore_netrc_null_auth():
+    args = httpie.cli.definition.parser.parse_args(
+        args=['--ignore-netrc', 'example.org'],
+        env=MockEnvironment(),
+    )
+    assert isinstance(args.auth, ExplicitNullAuth)

tests/test_auth_plugins.py

@@ -0,0 +1,135 @@
+from mock import mock
+
+from httpie.cli.constants import SEPARATOR_CREDENTIALS
+from httpie.plugins import AuthPlugin
+from httpie.plugins.registry import plugin_manager
+from utils import http, HTTP_OK
+
+
+# TODO: run all these tests in session mode as well
+
+USERNAME = 'user'
+PASSWORD = 'password'
+# Basic auth encoded `USERNAME` and `PASSWORD`
+# noinspection SpellCheckingInspection
+BASIC_AUTH_HEADER_VALUE = 'Basic dXNlcjpwYXNzd29yZA=='
+BASIC_AUTH_URL = '/basic-auth/{0}/{1}'.format(USERNAME, PASSWORD)
+AUTH_OK = {'authenticated': True, 'user': USERNAME}
+
+
+def basic_auth(header=BASIC_AUTH_HEADER_VALUE):
+
+    def inner(r):
+        r.headers['Authorization'] = header
+        return r
+
+    return inner
+
+
+def test_auth_plugin_parse_auth_false(httpbin):
+
+    class Plugin(AuthPlugin):
+        auth_type = 'test-parse-false'
+        auth_parse = False
+
+        def get_auth(self, username=None, password=None):
+            assert username is None
+            assert password is None
+            assert self.raw_auth == BASIC_AUTH_HEADER_VALUE
+            return basic_auth(self.raw_auth)
+
+    plugin_manager.register(Plugin)
+    try:
+        r = http(
+            httpbin + BASIC_AUTH_URL,
+            '--auth-type',
+            Plugin.auth_type,
+            '--auth',
+            BASIC_AUTH_HEADER_VALUE,
+        )
+        assert HTTP_OK in r
+        assert r.json == AUTH_OK
+    finally:
+        plugin_manager.unregister(Plugin)
+
+
+def test_auth_plugin_require_auth_false(httpbin):
+
+    class Plugin(AuthPlugin):
+        auth_type = 'test-require-false'
+        auth_require = False
+
+        def get_auth(self, username=None, password=None):
+            assert self.raw_auth is None
+            assert username is None
+            assert password is None
+            return basic_auth()
+
+    plugin_manager.register(Plugin)
+    try:
+        r = http(
+            httpbin + BASIC_AUTH_URL,
+            '--auth-type',
+            Plugin.auth_type,
+        )
+        assert HTTP_OK in r
+        assert r.json == AUTH_OK
+    finally:
+        plugin_manager.unregister(Plugin)
+
+
+def test_auth_plugin_require_auth_false_and_auth_provided(httpbin):
+
+    class Plugin(AuthPlugin):
+        auth_type = 'test-require-false-yet-provided'
+        auth_require = False
+
+        def get_auth(self, username=None, password=None):
+            assert self.raw_auth == USERNAME + SEPARATOR_CREDENTIALS + PASSWORD
+            assert username == USERNAME
+            assert password == PASSWORD
+            return basic_auth()
+
+    plugin_manager.register(Plugin)
+    try:
+        r = http(
+            httpbin + BASIC_AUTH_URL,
+            '--auth-type',
+            Plugin.auth_type,
+            '--auth',
+            USERNAME + SEPARATOR_CREDENTIALS + PASSWORD,
+        )
+        assert HTTP_OK in r
+        assert r.json == AUTH_OK
+    finally:
+        plugin_manager.unregister(Plugin)
+
+
+@mock.patch('httpie.cli.argtypes.AuthCredentials._getpass',
+            new=lambda self, prompt: 'UNEXPECTED_PROMPT_RESPONSE')
+def test_auth_plugin_prompt_password_false(httpbin):
+
+    class Plugin(AuthPlugin):
+        auth_type = 'test-prompt-false'
+        prompt_password = False
+
+        def get_auth(self, username=None, password=None):
+            assert self.raw_auth == USERNAME
+            assert username == USERNAME
+            assert password is None
+            return basic_auth()
+
+    plugin_manager.register(Plugin)
+
+    try:
+        r = http(
+            httpbin + BASIC_AUTH_URL,
+            '--auth-type',
+            Plugin.auth_type,
+            '--auth',
+            USERNAME,
+        )
+        assert HTTP_OK in r
+        assert r.json == AUTH_OK
+    finally:
+        plugin_manager.unregister(Plugin)

tests/test_binary.py

@@ -0,0 +1,50 @@
+"""Tests for dealing with binary request and response data."""
+import requests
+
+from fixtures import BIN_FILE_PATH, BIN_FILE_CONTENT, BIN_FILE_PATH_ARG
+from httpie.output.streams import BINARY_SUPPRESSED_NOTICE
+from utils import MockEnvironment, http
+
+
+class TestBinaryRequestData:
+
+    def test_binary_stdin(self, httpbin):
+        with open(BIN_FILE_PATH, 'rb') as stdin:
+            env = MockEnvironment(
+                stdin=stdin,
+                stdin_isatty=False,
+                stdout_isatty=False
+            )
+            r = http('--print=B', 'POST', httpbin.url + '/post', env=env)
+            assert r == BIN_FILE_CONTENT
+
+    def test_binary_file_path(self, httpbin):
+        env = MockEnvironment(stdin_isatty=True, stdout_isatty=False)
+        r = http('--print=B', 'POST', httpbin.url + '/post',
+                 '@' + BIN_FILE_PATH_ARG, env=env, )
+        assert r == BIN_FILE_CONTENT
+
+    def test_binary_file_form(self, httpbin):
+        env = MockEnvironment(stdin_isatty=True, stdout_isatty=False)
+        r = http('--print=B', '--form', 'POST', httpbin.url + '/post',
+                 'test@' + BIN_FILE_PATH_ARG, env=env)
+        assert bytes(BIN_FILE_CONTENT) in bytes(r)
+
+
+class TestBinaryResponseData:
+
+    def test_binary_suppresses_when_terminal(self, httpbin):
+        r = http('GET', httpbin + '/bytes/1024?seed=1')
+        assert BINARY_SUPPRESSED_NOTICE.decode() in r
+
+    def test_binary_suppresses_when_not_terminal_but_pretty(self, httpbin):
+        env = MockEnvironment(stdin_isatty=True, stdout_isatty=False)
+        r = http('--pretty=all', 'GET', httpbin + '/bytes/1024?seed=1', env=env)
+        assert BINARY_SUPPRESSED_NOTICE.decode() in r
+
+    def test_binary_included_and_correct_when_suitable(self, httpbin):
+        env = MockEnvironment(stdin_isatty=True, stdout_isatty=False)
+        url = httpbin + '/bytes/1024?seed=1'
+        r = http('GET', url, env=env)
+        expected = requests.get(url).content
+        assert r == expected

tests/test_cli.py

@@ -0,0 +1,355 @@
+"""CLI argument parsing related tests."""
+import argparse
+import json
+
+import pytest
+from requests.exceptions import InvalidSchema
+
+import httpie.cli.argparser
+from fixtures import (
+    FILE_CONTENT, FILE_PATH, FILE_PATH_ARG, JSON_FILE_CONTENT,
+    JSON_FILE_PATH_ARG,
+)
+from httpie.status import ExitStatus
+from httpie.cli import constants
+from httpie.cli.definition import parser
+from httpie.cli.argtypes import KeyValueArg, KeyValueArgType
+from httpie.cli.requestitems import RequestItems
+from utils import HTTP_OK, MockEnvironment, StdinBytesIO, http
+
+
+class TestItemParsing:
+    key_value_arg = KeyValueArgType(*constants.SEPARATOR_GROUP_ALL_ITEMS)
+
+    def test_invalid_items(self):
+        items = ['no-separator']
+        for item in items:
+            pytest.raises(argparse.ArgumentTypeError, self.key_value_arg, item)
+
+    def test_escape_separator(self):
+        items = RequestItems.from_args([
+            # headers
+            self.key_value_arg(r'foo\:bar:baz'),
+            self.key_value_arg(r'jack\@jill:hill'),
+
+            # data
+            self.key_value_arg(r'baz\=bar=foo'),
+
+            # files
+            self.key_value_arg(r'bar\@baz@%s' % FILE_PATH_ARG),
+        ])
+        # `requests.structures.CaseInsensitiveDict` => `dict`
+        headers = dict(items.headers._store.values())
+
+        assert headers == {
+            'foo:bar': 'baz',
+            'jack@jill': 'hill',
+        }
+        assert items.data == {
+            'baz=bar': 'foo'
+        }
+        assert 'bar@baz' in items.files
+
+    @pytest.mark.parametrize(('string', 'key', 'sep', 'value'), [
+        ('path=c:\\windows', 'path', '=', 'c:\\windows'),
+        ('path=c:\\windows\\', 'path', '=', 'c:\\windows\\'),
+        ('path\\==c:\\windows', 'path=', '=', 'c:\\windows'),
+    ])
+    def test_backslash_before_non_special_character_does_not_escape(
+        self, string, key, sep, value
+    ):
+        expected = KeyValueArg(orig=string, key=key, sep=sep, value=value)
+        actual = self.key_value_arg(string)
+        assert actual == expected
+
+    def test_escape_longsep(self):
+        items = RequestItems.from_args([
+            self.key_value_arg(r'bob\:==foo'),
+        ])
+        assert items.params == {
+            'bob:': 'foo'
+        }
+
+    def test_valid_items(self):
+        items = RequestItems.from_args([
+            self.key_value_arg('string=value'),
+            self.key_value_arg('Header:value'),
+            self.key_value_arg('Unset-Header:'),
+            self.key_value_arg('Empty-Header;'),
+            self.key_value_arg('list:=["a", 1, {}, false]'),
+            self.key_value_arg('obj:={"a": "b"}'),
+            self.key_value_arg('ed='),
+            self.key_value_arg('bool:=true'),
+            self.key_value_arg('file@' + FILE_PATH_ARG),
+            self.key_value_arg('query==value'),
+            self.key_value_arg('string-embed=@' + FILE_PATH_ARG),
+            self.key_value_arg('raw-json-embed:=@' + JSON_FILE_PATH_ARG),
+        ])
+
+        # Parsed headers
+        # `requests.structures.CaseInsensitiveDict` => `dict`
+        headers = dict(items.headers._store.values())
+        assert headers == {
+            'Header': 'value',
+            'Unset-Header': None,
+            'Empty-Header': ''
+        }
+
+        # Parsed data
+        raw_json_embed = items.data.pop('raw-json-embed')
+        assert raw_json_embed == json.loads(JSON_FILE_CONTENT)
+        items.data['string-embed'] = items.data['string-embed'].strip()
+        assert dict(items.data) == {
+            "ed": "",
+            "string": "value",
+            "bool": True,
+            "list": ["a", 1, {}, False],
+            "obj": {
+                "a": "b"
+            },
+            "string-embed": FILE_CONTENT,
+        }
+
+        # Parsed query string parameters
+        assert items.params == {
+            'query': 'value'
+        }
+
+        # Parsed file fields
+        assert 'file' in items.files
+        assert (items.files['file'][1].read().strip().
+                decode('utf8') == FILE_CONTENT)
+
+    def test_multiple_file_fields_with_same_field_name(self):
+        items = RequestItems.from_args([
+            self.key_value_arg('file_field@' + FILE_PATH_ARG),
+            self.key_value_arg('file_field@' + FILE_PATH_ARG),
+        ])
+        assert len(items.files['file_field']) == 2
+
+    def test_multiple_text_fields_with_same_field_name(self):
+        items = RequestItems.from_args(
+            request_item_args=[
+                self.key_value_arg('text_field=a'),
+                self.key_value_arg('text_field=b')
+            ],
+            as_form=True,
+        )
+        assert items.data['text_field'] == ['a', 'b']
+        assert list(items.data.items()) == [
+            ('text_field', 'a'),
+            ('text_field', 'b'),
+        ]
+
+
+class TestQuerystring:
+    def test_query_string_params_in_url(self, httpbin):
+        r = http('--print=Hhb', 'GET', httpbin.url + '/get?a=1&b=2')
+        path = '/get?a=1&b=2'
+        url = httpbin.url + path
+        assert HTTP_OK in r
+        assert 'GET %s HTTP/1.1' % path in r
+        assert '"url": "%s"' % url in r
+
+    def test_query_string_params_items(self, httpbin):
+        r = http('--print=Hhb', 'GET', httpbin.url + '/get', 'a==1')
+        path = '/get?a=1'
+        url = httpbin.url + path
+        assert HTTP_OK in r
+        assert 'GET %s HTTP/1.1' % path in r
+        assert '"url": "%s"' % url in r
+
+    def test_query_string_params_in_url_and_items_with_duplicates(self,
+                                                                  httpbin):
+        r = http('--print=Hhb', 'GET',
+                 httpbin.url + '/get?a=1&a=1', 'a==1', 'a==1')
+        path = '/get?a=1&a=1&a=1&a=1'
+        url = httpbin.url + path
+        assert HTTP_OK in r
+        assert 'GET %s HTTP/1.1' % path in r
+        assert '"url": "%s"' % url in r
+
+
+class TestLocalhostShorthand:
+    def test_expand_localhost_shorthand(self):
+        args = parser.parse_args(args=[':'], env=MockEnvironment())
+        assert args.url == 'http://localhost'
+
+    def test_expand_localhost_shorthand_with_slash(self):
+        args = parser.parse_args(args=[':/'], env=MockEnvironment())
+        assert args.url == 'http://localhost/'
+
+    def test_expand_localhost_shorthand_with_port(self):
+        args = parser.parse_args(args=[':3000'], env=MockEnvironment())
+        assert args.url == 'http://localhost:3000'
+
+    def test_expand_localhost_shorthand_with_path(self):
+        args = parser.parse_args(args=[':/path'], env=MockEnvironment())
+        assert args.url == 'http://localhost/path'
+
+    def test_expand_localhost_shorthand_with_port_and_slash(self):
+        args = parser.parse_args(args=[':3000/'], env=MockEnvironment())
+        assert args.url == 'http://localhost:3000/'
+
+    def test_expand_localhost_shorthand_with_port_and_path(self):
+        args = parser.parse_args(args=[':3000/path'], env=MockEnvironment())
+        assert args.url == 'http://localhost:3000/path'
+
+    def test_dont_expand_shorthand_ipv6_as_shorthand(self):
+        args = parser.parse_args(args=['::1'], env=MockEnvironment())
+        assert args.url == 'http://::1'
+
+    def test_dont_expand_longer_ipv6_as_shorthand(self):
+        args = parser.parse_args(
+            args=['::ffff:c000:0280'],
+            env=MockEnvironment()
+        )
+        assert args.url == 'http://::ffff:c000:0280'
+
+    def test_dont_expand_full_ipv6_as_shorthand(self):
+        args = parser.parse_args(
+            args=['0000:0000:0000:0000:0000:0000:0000:0001'],
+            env=MockEnvironment()
+        )
+        assert args.url == 'http://0000:0000:0000:0000:0000:0000:0000:0001'
+
+
+class TestArgumentParser:
+
+    def setup_method(self, method):
+        self.parser = httpie.cli.argparser.HTTPieArgumentParser()
+
+    def test_guess_when_method_set_and_valid(self):
+        self.parser.args = argparse.Namespace()
+        self.parser.args.method = 'GET'
+        self.parser.args.url = 'http://example.com/'
+        self.parser.args.request_items = []
+        self.parser.args.ignore_stdin = False
+        self.parser.env = MockEnvironment()
+        self.parser._guess_method()
+        assert self.parser.args.method == 'GET'
+        assert self.parser.args.url == 'http://example.com/'
+        assert self.parser.args.request_items == []
+
+    def test_guess_when_method_not_set(self):
+        self.parser.args = argparse.Namespace()
+        self.parser.args.method = None
+        self.parser.args.url = 'http://example.com/'
+        self.parser.args.request_items = []
+        self.parser.args.ignore_stdin = False
+        self.parser.env = MockEnvironment()
+        self.parser._guess_method()
+        assert self.parser.args.method == 'GET'
+        assert self.parser.args.url == 'http://example.com/'
+        assert self.parser.args.request_items == []
+
+    def test_guess_when_method_set_but_invalid_and_data_field(self):
+        self.parser.args = argparse.Namespace()
+        self.parser.args.method = 'http://example.com/'
+        self.parser.args.url = 'data=field'
+        self.parser.args.request_items = []
+        self.parser.args.ignore_stdin = False
+        self.parser.env = MockEnvironment()
+        self.parser._guess_method()
+        assert self.parser.args.method == 'POST'
+        assert self.parser.args.url == 'http://example.com/'
+        assert self.parser.args.request_items == [
+            KeyValueArg(key='data',
+                        value='field',
+                        sep='=',
+                        orig='data=field')
+        ]
+
+    def test_guess_when_method_set_but_invalid_and_header_field(self):
+        self.parser.args = argparse.Namespace()
+        self.parser.args.method = 'http://example.com/'
+        self.parser.args.url = 'test:header'
+        self.parser.args.request_items = []
+        self.parser.args.ignore_stdin = False
+        self.parser.env = MockEnvironment()
+        self.parser._guess_method()
+        assert self.parser.args.method == 'GET'
+        assert self.parser.args.url == 'http://example.com/'
+        assert self.parser.args.request_items, [
+            KeyValueArg(key='test',
+                        value='header',
+                        sep=':',
+                        orig='test:header')
+        ]
+
+    def test_guess_when_method_set_but_invalid_and_item_exists(self):
+        self.parser.args = argparse.Namespace()
+        self.parser.args.method = 'http://example.com/'
+        self.parser.args.url = 'new_item=a'
+        self.parser.args.request_items = [
+            KeyValueArg(
+                key='old_item', value='b', sep='=', orig='old_item=b')
+        ]
+        self.parser.args.ignore_stdin = False
+        self.parser.env = MockEnvironment()
+        self.parser._guess_method()
+        assert self.parser.args.request_items, [
+            KeyValueArg(key='new_item', value='a', sep='=', orig='new_item=a'),
+            KeyValueArg(
+                key='old_item', value='b', sep='=', orig='old_item=b'),
+        ]
+
+
+class TestNoOptions:
+
+    def test_valid_no_options(self, httpbin):
+        r = http('--verbose', '--no-verbose', 'GET', httpbin.url + '/get')
+        assert 'GET /get HTTP/1.1' not in r
+
+    def test_invalid_no_options(self, httpbin):
+        r = http('--no-war', 'GET', httpbin.url + '/get',
+                 tolerate_error_exit_status=True)
+        assert r.exit_status == ExitStatus.ERROR
+        assert 'unrecognized arguments: --no-war' in r.stderr
+        assert 'GET /get HTTP/1.1' not in r
+
+
+class TestStdin:
+
+    def test_ignore_stdin(self, httpbin):
+        env = MockEnvironment(
+            stdin=StdinBytesIO(FILE_PATH.read_bytes()),
+            stdin_isatty=False,
+        )
+        r = http('--ignore-stdin', '--verbose', httpbin.url + '/get', env=env)
+        assert HTTP_OK in r
+        assert 'GET /get HTTP' in r, "Don't default to POST."
+        assert FILE_CONTENT not in r, "Don't send stdin data."
+
+    def test_ignore_stdin_cannot_prompt_password(self, httpbin):
+        r = http('--ignore-stdin', '--auth=no-password', httpbin.url + '/get',
+                 tolerate_error_exit_status=True)
+        assert r.exit_status == ExitStatus.ERROR
+        assert 'because --ignore-stdin' in r.stderr
+
+    def test_stdin_closed(self, httpbin):
+        r = http(httpbin + '/get', env=MockEnvironment(stdin=None))
+        assert HTTP_OK in r
+
+
+class TestSchemes:
+
+    def test_invalid_custom_scheme(self):
+        # InvalidSchema is expected because HTTPie
+        # shouldn't touch a formally valid scheme.
+        with pytest.raises(InvalidSchema):
+            http('foo+bar-BAZ.123://bah')
+
+    def test_invalid_scheme_via_via_default_scheme(self):
+        # InvalidSchema is expected because HTTPie
+        # shouldn't touch a formally valid scheme.
+        with pytest.raises(InvalidSchema):
+            http('bah', '--default=scheme=foo+bar-BAZ.123')
+
+    def test_default_scheme_option(self, httpbin_secure):
+        url = '{0}:{1}'.format(httpbin_secure.host, httpbin_secure.port)
+        assert HTTP_OK in http(url, '--default-scheme=https')
+
+    def test_scheme_when_invoked_as_https(self, httpbin_secure):
+        url = '{0}:{1}'.format(httpbin_secure.host, httpbin_secure.port)
+        assert HTTP_OK in http(url, program_name='https')

tests/test_compress.py

@@ -0,0 +1,127 @@
+"""
+We test against httpbin which doesn't return the request data in a
+consistent way:
+
+1. Non-form requests: the `data` field contains base64 encoded version of
+our zlib-encoded request data.
+
+2. Form requests: `form` contains a messed up version of the data.
+
+"""
+import base64
+import zlib
+
+from fixtures import FILE_PATH, FILE_CONTENT
+from httpie.status import ExitStatus
+from utils import StdinBytesIO, http, HTTP_OK, MockEnvironment
+
+
+def assert_decompressed_equal(base64_compressed_data, expected_str):
+    compressed_data = base64.b64decode(
+        base64_compressed_data.split(',', 1)[1])
+    data = zlib.decompress(compressed_data)
+    actual_str = data.decode()
+
+    # FIXME: contains a trailing linebreak with an uploaded file
+    actual_str = actual_str.rstrip()
+
+    assert actual_str == expected_str
+
+
+def test_cannot_combine_compress_with_chunked(httpbin):
+    r = http('--compress', '--chunked', httpbin.url + '/get',
+             tolerate_error_exit_status=True)
+    assert r.exit_status == ExitStatus.ERROR
+    assert 'cannot combine --compress and --chunked' in r.stderr
+
+
+def test_cannot_combine_compress_with_multipart(httpbin):
+    r = http('--compress', '--multipart', httpbin.url + '/get',
+             tolerate_error_exit_status=True)
+    assert r.exit_status == ExitStatus.ERROR
+    assert 'cannot combine --compress and --multipart' in r.stderr
+
+
+def test_compress_skip_negative_ratio(httpbin_both):
+    r = http(
+        '--compress',
+        httpbin_both + '/post',
+        'foo=bar',
+    )
+    assert HTTP_OK in r
+    assert 'Content-Encoding' not in r.json['headers']
+    assert r.json['json'] == {'foo': 'bar'}
+
+
+def test_compress_force_with_negative_ratio(httpbin_both):
+    r = http(
+        '--compress',
+        '--compress',
+        httpbin_both + '/post',
+        'foo=bar',
+    )
+    assert HTTP_OK in r
+    assert r.json['headers']['Content-Encoding'] == 'deflate'
+    assert_decompressed_equal(r.json['data'], '{"foo": "bar"}')
+
+
+def test_compress_json(httpbin_both):
+    r = http(
+        '--compress',
+        '--compress',
+        httpbin_both + '/post',
+        'foo=bar',
+    )
+    assert HTTP_OK in r
+    assert r.json['headers']['Content-Encoding'] == 'deflate'
+    assert_decompressed_equal(r.json['data'], '{"foo": "bar"}')
+    assert r.json['json'] is None
+
+
+def test_compress_form(httpbin_both):
+    r = http(
+        '--form',
+        '--compress',
+        '--compress',
+        httpbin_both + '/post',
+        'foo=bar',
+    )
+    assert HTTP_OK in r
+    assert r.json['headers']['Content-Encoding'] == 'deflate'
+    assert r.json['data'] == ""
+    assert '"foo": "bar"' not in r
+
+
+def test_compress_stdin(httpbin_both):
+    env = MockEnvironment(
+        stdin=StdinBytesIO(FILE_PATH.read_bytes()),
+        stdin_isatty=False,
+    )
+    r = http(
+        '--compress',
+        '--compress',
+        'PATCH',
+        httpbin_both + '/patch',
+        env=env,
+    )
+    assert HTTP_OK in r
+    assert r.json['headers']['Content-Encoding'] == 'deflate'
+    assert_decompressed_equal(r.json['data'], FILE_CONTENT.strip())
+    assert not r.json['json']
+
+
+def test_compress_file(httpbin_both):
+    r = http(
+        '--form',
+        '--compress',
+        '--compress',
+        'PUT',
+        httpbin_both + '/put',
+        f'file@{FILE_PATH}',
+    )
+    assert HTTP_OK in r
+    assert r.json['headers']['Content-Encoding'] == 'deflate'
+    assert r.json['headers']['Content-Type'].startswith(
+        'multipart/form-data; boundary=')
+    assert r.json['files'] == {}
+    assert FILE_CONTENT not in r

tests/test_config.py

@@ -0,0 +1,104 @@
+from pathlib import Path
+
+import pytest
+from _pytest.monkeypatch import MonkeyPatch
+
+from httpie.compat import is_windows
+from httpie.config import (
+    Config, DEFAULT_CONFIG_DIRNAME, DEFAULT_RELATIVE_LEGACY_CONFIG_DIR,
+    DEFAULT_RELATIVE_XDG_CONFIG_HOME, DEFAULT_WINDOWS_CONFIG_DIR,
+    ENV_HTTPIE_CONFIG_DIR, ENV_XDG_CONFIG_HOME, get_default_config_dir,
+)
+from utils import HTTP_OK, MockEnvironment, http
+
+
+def test_default_options(httpbin):
+    env = MockEnvironment()
+    env.config['default_options'] = ['--form']
+    env.config.save()
+    r = http(httpbin.url + '/post', 'foo=bar', env=env)
+    assert r.json['form'] == {
+        "foo": "bar"
+    }
+
+
+def test_config_file_not_valid(httpbin):
+    env = MockEnvironment()
+    env.create_temp_config_dir()
+    with (env.config_dir / Config.FILENAME).open('w') as f:
+        f.write('{invalid json}')
+    r = http(httpbin + '/get', env=env)
+    assert HTTP_OK in r
+    assert 'http: warning' in r.stderr
+    assert 'invalid config file' in r.stderr
+
+
+@pytest.mark.skipif(is_windows, reason='cannot chmod 000 on Windows')
+def test_config_file_inaccessible(httpbin):
+    env = MockEnvironment()
+    env.create_temp_config_dir()
+    config_path = env.config_dir / Config.FILENAME
+    assert not config_path.exists()
+    config_path.touch(0o000)
+    assert config_path.exists()
+    r = http(httpbin + '/get', env=env)
+    assert HTTP_OK in r
+    assert 'http: warning' in r.stderr
+    assert 'cannot read config file' in r.stderr
+
+
+def test_default_options_overwrite(httpbin):
+    env = MockEnvironment()
+    env.config['default_options'] = ['--form']
+    env.config.save()
+    r = http('--json', httpbin.url + '/post', 'foo=bar', env=env)
+    assert r.json['json'] == {
+        "foo": "bar"
+    }
+
+
+@pytest.mark.skipif(is_windows, reason='XDG_CONFIG_HOME needs *nix')
+def test_explicit_xdg_config_home(monkeypatch: MonkeyPatch, tmp_path: Path):
+    home_dir = tmp_path
+    monkeypatch.delenv(ENV_HTTPIE_CONFIG_DIR, raising=False)
+    monkeypatch.setenv('HOME', str(home_dir))
+    custom_xdg_config_home = home_dir / 'custom_xdg_config_home'
+    monkeypatch.setenv(ENV_XDG_CONFIG_HOME, str(custom_xdg_config_home))
+    expected_config_dir = custom_xdg_config_home / DEFAULT_CONFIG_DIRNAME
+    assert get_default_config_dir() == expected_config_dir
+
+
+@pytest.mark.skipif(is_windows, reason='XDG_CONFIG_HOME needs *nix')
+def test_default_xdg_config_home(monkeypatch: MonkeyPatch, tmp_path: Path):
+    home_dir = tmp_path
+    monkeypatch.delenv(ENV_HTTPIE_CONFIG_DIR, raising=False)
+    monkeypatch.delenv(ENV_XDG_CONFIG_HOME, raising=False)
+    monkeypatch.setenv('HOME', str(home_dir))
+    expected_config_dir = (
+        home_dir
+        / DEFAULT_RELATIVE_XDG_CONFIG_HOME
+        / DEFAULT_CONFIG_DIRNAME
+    )
+    assert get_default_config_dir() == expected_config_dir
+
+
+@pytest.mark.skipif(is_windows, reason='legacy config dir needs *nix')
+def test_legacy_config_dir(monkeypatch: MonkeyPatch, tmp_path: Path):
+    home_dir = tmp_path
+    monkeypatch.delenv(ENV_HTTPIE_CONFIG_DIR, raising=False)
+    monkeypatch.setenv('HOME', str(home_dir))
+    legacy_config_dir = home_dir / DEFAULT_RELATIVE_LEGACY_CONFIG_DIR
+    legacy_config_dir.mkdir()
+    assert get_default_config_dir() == legacy_config_dir
+
+
+def test_custom_config_dir(monkeypatch: MonkeyPatch, tmp_path: Path):
+    httpie_config_dir = tmp_path / 'custom/directory'
+    monkeypatch.setenv(ENV_HTTPIE_CONFIG_DIR, str(httpie_config_dir))
+    assert get_default_config_dir() == httpie_config_dir
+
+
+@pytest.mark.skipif(not is_windows, reason='windows-only')
+def test_windows_config_dir(monkeypatch: MonkeyPatch):
+    monkeypatch.delenv(ENV_HTTPIE_CONFIG_DIR, raising=False)
+    assert get_default_config_dir() == DEFAULT_WINDOWS_CONFIG_DIR

tests/test_defaults.py

@@ -0,0 +1,127 @@
+"""
+Tests for the provided defaults regarding HTTP method, and --json vs. --form.
+
+"""
+from io import BytesIO
+
+from httpie.client import JSON_ACCEPT
+from utils import MockEnvironment, http, HTTP_OK
+from fixtures import FILE_PATH
+
+
+def test_default_headers_case_insensitive(httpbin):
+    """
+    <https://github.com/jakubroztocil/httpie/issues/644>
+    """
+    r = http(
+        '--debug',
+        '--print=H',
+        httpbin.url + '/post',
+        'CONTENT-TYPE:application/json-patch+json',
+        'a=b',
+    )
+    assert 'CONTENT-TYPE: application/json-patch+json' in r
+    assert 'Content-Type' not in r
+
+
+# noinspection PyPep8Naming
+class TestImplicitHTTPMethod:
+    def test_implicit_GET(self, httpbin):
+        r = http(httpbin.url + '/get')
+        assert HTTP_OK in r
+
+    def test_implicit_GET_with_headers(self, httpbin):
+        r = http(httpbin.url + '/headers', 'Foo:bar')
+        assert HTTP_OK in r
+        assert r.json['headers']['Foo'] == 'bar'
+
+    def test_implicit_POST_json(self, httpbin):
+        r = http(httpbin.url + '/post', 'hello=world')
+        assert HTTP_OK in r
+        assert r.json['json'] == {'hello': 'world'}
+
+    def test_implicit_POST_form(self, httpbin):
+        r = http('--form', httpbin.url + '/post', 'foo=bar')
+        assert HTTP_OK in r
+        assert r.json['form'] == {'foo': 'bar'}
+
+    def test_implicit_POST_stdin(self, httpbin):
+        env = MockEnvironment(
+            stdin_isatty=False,
+            stdin=BytesIO(FILE_PATH.read_bytes())
+        )
+        r = http('--form', httpbin.url + '/post', env=env)
+        assert HTTP_OK in r
+
+
+class TestAutoContentTypeAndAcceptHeaders:
+    """
+    Test that `Accept` and `Content-Type` correctly default to JSON,
+    but can still be overridden. The same with Content-Type when `--form`
+    `-f` is used.
+
+    """
+
+    def test_GET_no_data_no_auto_headers(self, httpbin):
+        # https://github.com/jakubroztocil/httpie/issues/62
+        r = http('GET', httpbin.url + '/headers')
+        assert HTTP_OK in r
+        assert r.json['headers']['Accept'] == '*/*'
+        assert 'Content-Type' not in r.json['headers']
+
+    def test_POST_no_data_no_auto_headers(self, httpbin):
+        # JSON headers shouldn't be automatically set for POST with no data.
+        r = http('POST', httpbin.url + '/post')
+        assert HTTP_OK in r
+        assert '"Accept": "*/*"' in r
+        assert '"Content-Type": "application/json' not in r
+
+    def test_POST_with_data_auto_JSON_headers(self, httpbin):
+        r = http('POST', httpbin.url + '/post', 'a=b')
+        assert HTTP_OK in r
+        assert r.json['headers']['Accept'] == JSON_ACCEPT
+        assert r.json['headers']['Content-Type'] == 'application/json'
+
+    def test_GET_with_data_auto_JSON_headers(self, httpbin):
+        # JSON headers should automatically be set also for GET with data.
+        r = http('POST', httpbin.url + '/post', 'a=b')
+        assert HTTP_OK in r
+        assert r.json['headers']['Accept'] == JSON_ACCEPT
+        assert r.json['headers']['Content-Type'] == 'application/json'
+
+    def test_POST_explicit_JSON_JSON_ACCEPT(self, httpbin):
+        r = http('--json', 'POST', httpbin.url + '/post')
+        assert HTTP_OK in r
+        assert r.json['headers']['Accept'] == JSON_ACCEPT
+        # Make sure Content-Type gets set even with no data.
+        # https://github.com/jakubroztocil/httpie/issues/137
+        assert 'application/json' in r.json['headers']['Content-Type']
+
+    def test_GET_explicit_JSON_explicit_headers(self, httpbin):
+        r = http('--json', 'GET', httpbin.url + '/headers',
+                 'Accept:application/xml',
+                 'Content-Type:application/xml')
+        assert HTTP_OK in r
+        assert '"Accept": "application/xml"' in r
+        assert '"Content-Type": "application/xml"' in r
+
+    def test_POST_form_auto_Content_Type(self, httpbin):
+        r = http('--form', 'POST', httpbin.url + '/post')
+        assert HTTP_OK in r
+        assert '"Content-Type": "application/x-www-form-urlencoded' in r
+
+    def test_POST_form_Content_Type_override(self, httpbin):
+        r = http('--form', 'POST', httpbin.url + '/post',
+                 'Content-Type:application/xml')
+        assert HTTP_OK in r
+        assert '"Content-Type": "application/xml"' in r
+
+    def test_print_only_body_when_stdout_redirected_by_default(self, httpbin):
+        env = MockEnvironment(stdin_isatty=True, stdout_isatty=False)
+        r = http('GET', httpbin.url + '/get', env=env)
+        assert 'HTTP/' not in r
+
+    def test_print_overridable_when_stdout_redirected(self, httpbin):
+        env = MockEnvironment(stdin_isatty=True, stdout_isatty=False)
+        r = http('--print=h', 'GET', httpbin.url + '/get', env=env)
+        assert HTTP_OK in r

tests/test_docs.py

@@ -0,0 +1,69 @@
+import os
+import subprocess
+from glob import glob
+from pathlib import Path
+
+import pytest
+
+from utils import TESTS_ROOT
+
+
+SOURCE_DIRECTORIES = [
+    'extras',
+    'httpie',
+    'tests',
+]
+
+
+def has_docutils():
+    try:
+        # noinspection PyUnresolvedReferences,PyPackageRequirements
+        import docutils
+        return True
+    except ImportError:
+        return False
+
+
+def rst_filenames():
+    cwd = os.getcwd()
+    os.chdir(TESTS_ROOT.parent)
+    try:
+        yield from glob('*.rst')
+        for directory in SOURCE_DIRECTORIES:
+            yield from glob(f'{directory}/**/*.rst', recursive=True)
+    finally:
+        os.chdir(cwd)
+
+
+filenames = list(sorted(rst_filenames()))
+assert filenames
+
+
+# HACK: hardcoded paths, venv should be irrelevant, etc.
+# TODO: simplify by using the Python API instead of a subprocess
+#       then we wont’t need the paths.
+VENV_BIN = Path(__file__).parent.parent / 'venv/bin'
+VENV_PYTHON = VENV_BIN / 'python'
+VENV_RST2PSEUDOXML = VENV_BIN / 'rst2pseudoxml.py'
+
+
+@pytest.mark.skipif(
+    not VENV_RST2PSEUDOXML.exists(),
+    reason='docutils not installed',
+)
+@pytest.mark.parametrize('filename', filenames)
+def test_rst_file_syntax(filename):
+    p = subprocess.Popen(
+        [
+            VENV_PYTHON,
+            VENV_RST2PSEUDOXML,
+            '--report=1',
+            '--exit-status=1',
+            filename,
+        ],
+        stderr=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        shell=True,
+    )
+    err = p.communicate()[1]
+    assert p.returncode == 0, err.decode('utf8')

tests/test_downloads.py

@@ -0,0 +1,193 @@
+import os
+import tempfile
+import time
+from urllib.request import urlopen
+
+import pytest
+import mock
+import requests
+from requests.structures import CaseInsensitiveDict
+
+from httpie.downloads import (
+    parse_content_range, filename_from_content_disposition, filename_from_url,
+    get_unique_filename, ContentRangeError, Downloader,
+)
+from utils import http, MockEnvironment
+
+
+class Response:
+    # noinspection PyDefaultArgument
+    def __init__(self, url, headers={}, status_code=200):
+        self.url = url
+        self.headers = CaseInsensitiveDict(headers)
+        self.status_code = status_code
+
+
+class TestDownloadUtils:
+
+    def test_Content_Range_parsing(self):
+        parse = parse_content_range
+
+        assert parse('bytes 100-199/200', 100) == 200
+        assert parse('bytes 100-199/*', 100) == 200
+
+        # missing
+        pytest.raises(ContentRangeError, parse, None, 100)
+
+        # syntax error
+        pytest.raises(ContentRangeError, parse, 'beers 100-199/*', 100)
+
+        # unexpected range
+        pytest.raises(ContentRangeError, parse, 'bytes 100-199/*', 99)
+
+        # invalid instance-length
+        pytest.raises(ContentRangeError, parse, 'bytes 100-199/199', 100)
+
+        # invalid byte-range-resp-spec
+        pytest.raises(ContentRangeError, parse, 'bytes 100-99/199', 100)
+
+        # invalid byte-range-resp-spec
+        pytest.raises(ContentRangeError, parse, 'bytes 100-100/*', 100)
+
+    @pytest.mark.parametrize('header, expected_filename', [
+        ('attachment; filename=hello-WORLD_123.txt', 'hello-WORLD_123.txt'),
+        ('attachment; filename=".hello-WORLD_123.txt"', 'hello-WORLD_123.txt'),
+        ('attachment; filename="white space.txt"', 'white space.txt'),
+        (r'attachment; filename="\"quotes\".txt"', '"quotes".txt'),
+        ('attachment; filename=/etc/hosts', 'hosts'),
+        ('attachment; filename=', None)
+    ])
+    def test_Content_Disposition_parsing(self, header, expected_filename):
+        assert filename_from_content_disposition(header) == expected_filename
+
+    def test_filename_from_url(self):
+        assert 'foo.txt' == filename_from_url(
+            url='http://example.org/foo',
+            content_type='text/plain'
+        )
+        assert 'foo.html' == filename_from_url(
+            url='http://example.org/foo',
+            content_type='text/html; charset=utf8'
+        )
+        assert 'foo' == filename_from_url(
+            url='http://example.org/foo',
+            content_type=None
+        )
+        assert 'foo' == filename_from_url(
+            url='http://example.org/foo',
+            content_type='x-foo/bar'
+        )
+
+    @pytest.mark.parametrize(
+        'orig_name, unique_on_attempt, expected',
+        [
+            # Simple
+            ('foo.bar', 0, 'foo.bar'),
+            ('foo.bar', 1, 'foo.bar-1'),
+            ('foo.bar', 10, 'foo.bar-10'),
+            # Trim
+            ('A' * 20, 0, 'A' * 10),
+            ('A' * 20, 1, 'A' * 8 + '-1'),
+            ('A' * 20, 10, 'A' * 7 + '-10'),
+            # Trim before ext
+            ('A' * 20 + '.txt', 0, 'A' * 6 + '.txt'),
+            ('A' * 20 + '.txt', 1, 'A' * 4 + '.txt-1'),
+            # Trim at the end
+            ('foo.' + 'A' * 20, 0, 'foo.' + 'A' * 6),
+            ('foo.' + 'A' * 20, 1, 'foo.' + 'A' * 4 + '-1'),
+            ('foo.' + 'A' * 20, 10, 'foo.' + 'A' * 3 + '-10'),
+        ]
+    )
+    @mock.patch('httpie.downloads.get_filename_max_length')
+    def test_unique_filename(self, get_filename_max_length,
+                             orig_name, unique_on_attempt,
+                             expected):
+
+        def attempts(unique_on_attempt=0):
+            # noinspection PyUnresolvedReferences,PyUnusedLocal
+            def exists(filename):
+                if exists.attempt == unique_on_attempt:
+                    return False
+                exists.attempt += 1
+                return True
+
+            exists.attempt = 0
+            return exists
+
+        get_filename_max_length.return_value = 10
+
+        actual = get_unique_filename(orig_name, attempts(unique_on_attempt))
+        assert expected == actual
+
+
+class TestDownloads:
+    # TODO: more tests
+
+    def test_actual_download(self, httpbin_both, httpbin):
+        robots_txt = '/robots.txt'
+        body = urlopen(httpbin + robots_txt).read().decode()
+        env = MockEnvironment(stdin_isatty=True, stdout_isatty=False)
+        r = http('--download', httpbin_both.url + robots_txt, env=env)
+        assert 'Downloading' in r.stderr
+        assert '[K' in r.stderr
+        assert 'Done' in r.stderr
+        assert body == r
+
+    def test_download_with_Content_Length(self, httpbin_both):
+        with open(os.devnull, 'w') as devnull:
+            downloader = Downloader(output_file=devnull, progress_file=devnull)
+            downloader.start(
+                initial_url='/',
+                final_response=Response(
+                    url=httpbin_both.url + '/',
+                    headers={'Content-Length': 10}
+                )
+            )
+            time.sleep(1.1)
+            downloader.chunk_downloaded(b'12345')
+            time.sleep(1.1)
+            downloader.chunk_downloaded(b'12345')
+            downloader.finish()
+            assert not downloader.interrupted
+            downloader._progress_reporter.join()
+
+    def test_download_no_Content_Length(self, httpbin_both):
+        with open(os.devnull, 'w') as devnull:
+            downloader = Downloader(output_file=devnull, progress_file=devnull)
+            downloader.start(
+                final_response=Response(url=httpbin_both.url + '/'),
+                initial_url='/'
+            )
+            time.sleep(1.1)
+            downloader.chunk_downloaded(b'12345')
+            downloader.finish()
+            assert not downloader.interrupted
+            downloader._progress_reporter.join()
+
+    def test_download_interrupted(self, httpbin_both):
+        with open(os.devnull, 'w') as devnull:
+            downloader = Downloader(output_file=devnull, progress_file=devnull)
+            downloader.start(
+                final_response=Response(
+                    url=httpbin_both.url + '/',
+                    headers={'Content-Length': 5}
+                ),
+                initial_url='/'
+            )
+            downloader.chunk_downloaded(b'1234')
+            downloader.finish()
+            assert downloader.interrupted
+            downloader._progress_reporter.join()
+
+    def test_download_with_redirect_original_url_used_for_filename(self, httpbin):
+        # Redirect from `/redirect/1` to `/get`.
+        expected_filename = '1.json'
+        orig_cwd = os.getcwd()
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            os.chdir(tmp_dirname)
+            try:
+                assert os.listdir('.') == []
+                http('--download', httpbin.url + '/redirect/1')
+                assert os.listdir('.') == [expected_filename]
+            finally:
+                os.chdir(orig_cwd)

tests/test_errors.py

@@ -0,0 +1,41 @@
+import mock
+from pytest import raises
+from requests import Request
+from requests.exceptions import ConnectionError
+
+from httpie.status import ExitStatus
+from utils import HTTP_OK, http
+
+
+@mock.patch('httpie.core.program')
+def test_error(program):
+    exc = ConnectionError('Connection aborted')
+    exc.request = Request(method='GET', url='http://www.google.com')
+    program.side_effect = exc
+    r = http('www.google.com', tolerate_error_exit_status=True)
+    assert r.exit_status == ExitStatus.ERROR
+    error_msg = (
+        'ConnectionError: '
+        'Connection aborted while doing a GET request to URL: '
+        'http://www.google.com'
+    )
+    assert error_msg in r.stderr
+
+
+@mock.patch('httpie.core.program')
+def test_error_traceback(program):
+    exc = ConnectionError('Connection aborted')
+    exc.request = Request(method='GET', url='http://www.google.com')
+    program.side_effect = exc
+    with raises(ConnectionError):
+        http('--traceback', 'www.google.com')
+
+
+def test_max_headers_limit(httpbin_both):
+    with raises(ConnectionError) as e:
+        http('--max-headers=1', httpbin_both + '/get')
+    assert 'got more than 1 headers' in str(e.value)
+
+
+def test_max_headers_no_limit(httpbin_both):
+    assert HTTP_OK in http('--max-headers=0', httpbin_both + '/get')

tests/test_exit_status.py

@@ -0,0 +1,74 @@
+import mock
+
+from httpie.status import ExitStatus
+from utils import MockEnvironment, http, HTTP_OK
+
+
+def test_keyboard_interrupt_during_arg_parsing_exit_status(httpbin):
+    with mock.patch('httpie.cli.definition.parser.parse_args',
+                    side_effect=KeyboardInterrupt()):
+        r = http('GET', httpbin.url + '/get', tolerate_error_exit_status=True)
+        assert r.exit_status == ExitStatus.ERROR_CTRL_C
+
+
+def test_keyboard_interrupt_in_program_exit_status(httpbin):
+    with mock.patch('httpie.core.program',
+                    side_effect=KeyboardInterrupt()):
+        r = http('GET', httpbin.url + '/get', tolerate_error_exit_status=True)
+        assert r.exit_status == ExitStatus.ERROR_CTRL_C
+
+
+def test_ok_response_exits_0(httpbin):
+    r = http('GET', httpbin.url + '/get')
+    assert HTTP_OK in r
+    assert r.exit_status == ExitStatus.SUCCESS
+
+
+def test_error_response_exits_0_without_check_status(httpbin):
+    r = http('GET', httpbin.url + '/status/500')
+    assert '500 INTERNAL SERVER ERROR' in r
+    assert r.exit_status == ExitStatus.SUCCESS
+    assert not r.stderr
+
+
+def test_timeout_exit_status(httpbin):
+
+    r = http('--timeout=0.01', 'GET', httpbin.url + '/delay/0.5',
+             tolerate_error_exit_status=True)
+    assert r.exit_status == ExitStatus.ERROR_TIMEOUT
+
+
+def test_3xx_check_status_exits_3_and_stderr_when_stdout_redirected(
+        httpbin):
+    env = MockEnvironment(stdout_isatty=False)
+    r = http('--check-status', '--headers',
+             'GET', httpbin.url + '/status/301',
+             env=env, tolerate_error_exit_status=True)
+    assert '301 MOVED PERMANENTLY' in r
+    assert r.exit_status == ExitStatus.ERROR_HTTP_3XX
+    assert '301 moved permanently' in r.stderr.lower()
+
+
+def test_3xx_check_status_redirects_allowed_exits_0(httpbin):
+    r = http('--check-status', '--follow',
+             'GET', httpbin.url + '/status/301',
+             tolerate_error_exit_status=True)
+    # The redirect will be followed so 200 is expected.
+    assert HTTP_OK in r
+    assert r.exit_status == ExitStatus.SUCCESS
+
+
+def test_4xx_check_status_exits_4(httpbin):
+    r = http('--check-status', 'GET', httpbin.url + '/status/401',
+             tolerate_error_exit_status=True)
+    assert '401 UNAUTHORIZED' in r
+    assert r.exit_status == ExitStatus.ERROR_HTTP_4XX
+    # Also stderr should be empty since stdout isn't redirected.
+    assert not r.stderr
+
+
+def test_5xx_check_status_exits_5(httpbin):
+    r = http('--check-status', 'GET', httpbin.url + '/status/500',
+             tolerate_error_exit_status=True)
+    assert '500 INTERNAL SERVER ERROR' in r
+    assert r.exit_status == ExitStatus.ERROR_HTTP_5XX

tests/test_httpie.py

@@ -0,0 +1,185 @@
+"""High-level tests."""
+import io
+from unittest import mock
+
+import pytest
+
+import httpie
+import httpie.__main__
+from fixtures import FILE_CONTENT, FILE_PATH
+from httpie.cli.exceptions import ParseError
+from httpie.context import Environment
+from httpie.status import ExitStatus
+from utils import HTTP_OK, MockEnvironment, StdinBytesIO, http
+
+
+def test_main_entry_point():
+    # Patch stdin to bypass pytest capture
+    with mock.patch.object(Environment, 'stdin', io.StringIO()):
+        with pytest.raises(SystemExit) as e:
+            httpie.__main__.main()
+        assert e.value.code == ExitStatus.ERROR
+
+
+@mock.patch('httpie.core.main')
+def test_main_entry_point_keyboard_interrupt(main):
+    main.side_effect = KeyboardInterrupt()
+    with mock.patch.object(Environment, 'stdin', io.StringIO()):
+        with pytest.raises(SystemExit) as e:
+            httpie.__main__.main()
+        assert e.value.code == ExitStatus.ERROR_CTRL_C
+
+
+def test_debug():
+    r = http('--debug')
+    assert r.exit_status == ExitStatus.SUCCESS
+    assert 'HTTPie %s' % httpie.__version__ in r.stderr
+
+
+def test_help():
+    r = http('--help', tolerate_error_exit_status=True)
+    assert r.exit_status == ExitStatus.SUCCESS
+    assert 'https://github.com/jakubroztocil/httpie/issues' in r
+
+
+def test_version():
+    r = http('--version', tolerate_error_exit_status=True)
+    assert r.exit_status == ExitStatus.SUCCESS
+    assert httpie.__version__ == r.strip()
+
+
+def test_GET(httpbin_both):
+    r = http('GET', httpbin_both + '/get')
+    assert HTTP_OK in r
+
+
+def test_path_dot_normalization():
+    r = http(
+        '--offline',
+        'example.org/../../etc/password',
+        'param==value'
+    )
+    assert 'GET /etc/password?param=value' in r
+
+
+def test_path_as_is():
+    r = http(
+        '--offline',
+        '--path-as-is',
+        'example.org/../../etc/password',
+        'param==value'
+    )
+    assert 'GET /../../etc/password?param=value' in r
+
+
+def test_DELETE(httpbin_both):
+    r = http('DELETE', httpbin_both + '/delete')
+    assert HTTP_OK in r
+
+
+def test_PUT(httpbin_both):
+    r = http('PUT', httpbin_both + '/put', 'foo=bar')
+    assert HTTP_OK in r
+    assert r.json['json']['foo'] == 'bar'
+
+
+def test_POST_JSON_data(httpbin_both):
+    r = http('POST', httpbin_both + '/post', 'foo=bar')
+    assert HTTP_OK in r
+    assert r.json['json']['foo'] == 'bar'
+
+
+def test_POST_form(httpbin_both):
+    r = http('--form', 'POST', httpbin_both + '/post', 'foo=bar')
+    assert HTTP_OK in r
+    assert '"foo": "bar"' in r
+
+
+def test_POST_form_multiple_values(httpbin_both):
+    r = http('--form', 'POST', httpbin_both + '/post', 'foo=bar', 'foo=baz')
+    assert HTTP_OK in r
+    assert r.json['form'] == {
+        'foo': ['bar', 'baz']
+    }
+
+
+def test_POST_stdin(httpbin_both):
+    env = MockEnvironment(
+        stdin=StdinBytesIO(FILE_PATH.read_bytes()),
+        stdin_isatty=False,
+    )
+    r = http('--form', 'POST', httpbin_both + '/post', env=env)
+    assert HTTP_OK in r
+    assert FILE_CONTENT in r
+
+
+def test_POST_file(httpbin_both):
+    r = http('--form', 'POST', httpbin_both + '/post', f'file@{FILE_PATH}')
+    assert HTTP_OK in r
+    assert FILE_CONTENT in r
+
+
+def test_form_POST_file_redirected_stdin(httpbin):
+    """
+    <https://github.com/jakubroztocil/httpie/issues/840>
+
+    """
+    with open(FILE_PATH) as f:
+        r = http(
+            '--form',
+            'POST',
+            httpbin + '/post',
+            f'file@{FILE_PATH}',
+            tolerate_error_exit_status=True,
+            env=MockEnvironment(
+                stdin=StdinBytesIO(FILE_PATH.read_bytes()),
+                stdin_isatty=False,
+            ),
+        )
+    assert r.exit_status == ExitStatus.ERROR
+    assert 'cannot be mixed' in r.stderr
+
+
+def test_headers(httpbin_both):
+    r = http('GET', httpbin_both + '/headers', 'Foo:bar')
+    assert HTTP_OK in r
+    assert '"User-Agent": "HTTPie' in r, r
+    assert '"Foo": "bar"' in r
+
+
+def test_headers_unset(httpbin_both):
+    r = http('GET', httpbin_both + '/headers')
+    assert 'Accept' in r.json['headers']  # default Accept present
+
+    r = http('GET', httpbin_both + '/headers', 'Accept:')
+    assert 'Accept' not in r.json['headers']  # default Accept unset
+
+
+@pytest.mark.skip('unimplemented')
+def test_unset_host_header(httpbin_both):
+    r = http('GET', httpbin_both + '/headers')
+    assert 'Host' in r.json['headers']  # default Host present
+
+    r = http('GET', httpbin_both + '/headers', 'Host:')
+    assert 'Host' not in r.json['headers']  # default Host unset
+
+
+def test_headers_empty_value(httpbin_both):
+    r = http('GET', httpbin_both + '/headers')
+    assert r.json['headers']['Accept']  # default Accept has value
+
+    r = http('GET', httpbin_both + '/headers', 'Accept;')
+    assert r.json['headers']['Accept'] == ''  # Accept has no value
+
+
+def test_headers_empty_value_with_value_gives_error(httpbin):
+    with pytest.raises(ParseError):
+        http('GET', httpbin + '/headers', 'Accept;SYNTAX_ERROR')
+
+
+def test_json_input_preserve_order(httpbin_both):
+    r = http('PATCH', httpbin_both + '/patch',
+             'order:={"map":{"1":"first","2":"second"}}')
+    assert HTTP_OK in r
+    assert r.json['data'] == \
+           '{"order": {"map": {"1": "first", "2": "second"}}}'

tests/test_offline.py

@@ -0,0 +1,75 @@
+from fixtures import FILE_CONTENT, FILE_PATH_ARG
+from utils import http
+
+
+def test_offline():
+    r = http(
+        '--offline',
+        'https://this-should.never-resolve/foo',
+    )
+    assert 'GET /foo' in r
+
+
+def test_offline_form():
+    r = http(
+        '--offline',
+        '--form',
+        'https://this-should.never-resolve/foo',
+        'foo=bar'
+    )
+    assert 'POST /foo' in r
+    assert 'foo=bar' in r
+
+
+def test_offline_json():
+    r = http(
+        '--offline',
+        'https://this-should.never-resolve/foo',
+        'foo=bar'
+    )
+    assert 'POST /foo' in r
+    assert r.json == {'foo': 'bar'}
+
+
+def test_offline_multipart():
+    r = http(
+        '--offline',
+        '--multipart',
+        'https://this-should.never-resolve/foo',
+        'foo=bar'
+    )
+    assert 'POST /foo' in r
+    assert 'name="foo"' in r
+
+
+def test_offline_from_file():
+    r = http(
+        '--offline',
+        'https://this-should.never-resolve/foo',
+        f'@{FILE_PATH_ARG}'
+    )
+    assert 'POST /foo' in r
+    assert FILE_CONTENT in r
+
+
+def test_offline_chunked():
+    r = http(
+        '--offline',
+        '--chunked',
+        '--form',
+        'https://this-should.never-resolve/foo',
+        'hello=world'
+    )
+    assert 'POST /foo' in r
+    assert 'Transfer-Encoding: chunked' in r, r
+    assert 'hello=world' in r
+
+
+def test_offline_download():
+    """Absence of response should be handled gracefully with --download"""
+    r = http(
+        '--offline',
+        '--download',
+        'https://this-should.never-resolve/foo',
+    )
+    assert 'GET /foo' in r

tests/test_output.py

@@ -0,0 +1,464 @@
+import argparse
+from pathlib import Path
+
+import mock
+import json
+import os
+import tempfile
+import io
+from tempfile import gettempdir
+from urllib.request import urlopen
+
+import pytest
+import requests
+
+from httpie.cli.argtypes import (
+    PARSED_DEFAULT_FORMAT_OPTIONS,
+    parse_format_options,
+)
+from httpie.cli.definition import parser
+from httpie.output.formatters.colors import get_lexer
+from httpie.status import ExitStatus
+from utils import COLOR, CRLF, HTTP_OK, MockEnvironment, http
+
+
+@pytest.mark.parametrize('stdout_isatty', [True, False])
+def test_output_option(httpbin, stdout_isatty):
+    output_filename = os.path.join(gettempdir(), test_output_option.__name__)
+    url = httpbin + '/robots.txt'
+
+    r = http('--output', output_filename, url,
+             env=MockEnvironment(stdout_isatty=stdout_isatty))
+    assert r == ''
+
+    expected_body = urlopen(url).read().decode()
+    with open(output_filename, 'r') as f:
+        actual_body = f.read()
+
+    assert actual_body == expected_body
+
+
+class TestQuietFlag:
+
+    @pytest.mark.parametrize('argument_name', ['--quiet', '-q'])
+    def test_quiet(self, httpbin, argument_name):
+        env = MockEnvironment(
+            stdin_isatty=True,
+            stdout_isatty=True,
+            devnull=io.BytesIO()
+        )
+        r = http(argument_name, 'GET', httpbin.url + '/get', env=env)
+        assert env.stdout is env.devnull
+        assert env.stderr is env.devnull
+        assert HTTP_OK in r.devnull
+        assert r == ''
+        assert r.stderr == ''
+
+    @mock.patch('httpie.cli.argtypes.AuthCredentials._getpass',
+                new=lambda self, prompt: 'password')
+    def test_quiet_with_password_prompt(self, httpbin):
+        """
+        Tests whether httpie still prompts for a password when request
+        requires authentication and only username is provided
+
+        """
+        env = MockEnvironment(
+            stdin_isatty=True,
+            stdout_isatty=True,
+            devnull=io.BytesIO()
+        )
+        r = http(
+            '--quiet', '--auth', 'user', 'GET',
+            httpbin.url + '/basic-auth/user/password',
+            env=env
+        )
+        assert env.stdout is env.devnull
+        assert env.stderr is env.devnull
+        assert HTTP_OK in r.devnull
+        assert r == ''
+        assert r.stderr == ''
+
+    @pytest.mark.parametrize('argument_name', ['-h', '-b', '-v', '-p=hH'])
+    def test_quiet_with_explicit_output_options(self, httpbin, argument_name):
+        env = MockEnvironment(stdin_isatty=True, stdout_isatty=True)
+        r = http('--quiet', argument_name, httpbin.url + '/get', env=env)
+        assert env.stdout is env.devnull
+        assert env.stderr is env.devnull
+        assert r == ''
+        assert r.stderr == ''
+
+    @pytest.mark.parametrize('with_download', [True, False])
+    def test_quiet_with_output_redirection(self, httpbin, with_download):
+        url = httpbin + '/robots.txt'
+        output_path = Path('output.txt')
+        env = MockEnvironment()
+        orig_cwd = os.getcwd()
+        output = requests.get(url).text
+        extra_args = ['--download'] if with_download else []
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            os.chdir(tmp_dirname)
+            try:
+                assert os.listdir('.') == []
+                r = http(
+                    '--quiet',
+                    '--output', str(output_path),
+                    *extra_args,
+                    url,
+                    env=env
+                )
+                assert os.listdir('.') == [str(output_path)]
+                assert r == ''
+                assert r.stderr == ''
+                assert env.stderr is env.devnull
+                if with_download:
+                    assert env.stdout is env.devnull
+                else:
+                    assert env.stdout is not env.devnull  # --output swaps stdout.
+                assert output_path.read_text() == output
+            finally:
+                os.chdir(orig_cwd)
+
+
+class TestVerboseFlag:
+    def test_verbose(self, httpbin):
+        r = http('--verbose',
+                 'GET', httpbin.url + '/get', 'test-header:__test__')
+        assert HTTP_OK in r
+        assert r.count('__test__') == 2
+
+    def test_verbose_form(self, httpbin):
+        # https://github.com/jakubroztocil/httpie/issues/53
+        r = http('--verbose', '--form', 'POST', httpbin.url + '/post',
+                 'A=B', 'C=D')
+        assert HTTP_OK in r
+        assert 'A=B&C=D' in r
+
+    def test_verbose_json(self, httpbin):
+        r = http('--verbose',
+                 'POST', httpbin.url + '/post', 'foo=bar', 'baz=bar')
+        assert HTTP_OK in r
+        assert '"baz": "bar"' in r
+
+    def test_verbose_implies_all(self, httpbin):
+        r = http('--verbose', '--follow', httpbin + '/redirect/1')
+        assert 'GET /redirect/1 HTTP/1.1' in r
+        assert 'HTTP/1.1 302 FOUND' in r
+        assert 'GET /get HTTP/1.1' in r
+        assert HTTP_OK in r
+
+
+class TestColors:
+
+    @pytest.mark.parametrize(
+        argnames=['mime', 'explicit_json', 'body', 'expected_lexer_name'],
+        argvalues=[
+            ('application/json', False, None, 'JSON'),
+            ('application/json+foo', False, None, 'JSON'),
+            ('application/foo+json', False, None, 'JSON'),
+            ('application/json-foo', False, None, 'JSON'),
+            ('application/x-json', False, None, 'JSON'),
+            ('foo/json', False, None, 'JSON'),
+            ('foo/json+bar', False, None, 'JSON'),
+            ('foo/bar+json', False, None, 'JSON'),
+            ('foo/json-foo', False, None, 'JSON'),
+            ('foo/x-json', False, None, 'JSON'),
+            ('application/vnd.comverge.grid+hal+json', False, None, 'JSON'),
+            ('text/plain', True, '{}', 'JSON'),
+            ('text/plain', True, 'foo', 'Text only'),
+        ]
+    )
+    def test_get_lexer(self, mime, explicit_json, body, expected_lexer_name):
+        lexer = get_lexer(mime, body=body, explicit_json=explicit_json)
+        assert lexer is not None
+        assert lexer.name == expected_lexer_name
+
+    def test_get_lexer_not_found(self):
+        assert get_lexer('xxx/yyy') is None
+
+
+class TestPrettyOptions:
+    """Test the --pretty handling."""
+
+    def test_pretty_enabled_by_default(self, httpbin):
+        env = MockEnvironment(colors=256)
+        r = http('GET', httpbin.url + '/get', env=env)
+        assert COLOR in r
+
+    def test_pretty_enabled_by_default_unless_stdout_redirected(self, httpbin):
+        r = http('GET', httpbin.url + '/get')
+        assert COLOR not in r
+
+    def test_force_pretty(self, httpbin):
+        env = MockEnvironment(stdout_isatty=False, colors=256)
+        r = http('--pretty=all', 'GET', httpbin.url + '/get', env=env, )
+        assert COLOR in r
+
+    def test_force_ugly(self, httpbin):
+        r = http('--pretty=none', 'GET', httpbin.url + '/get')
+        assert COLOR not in r
+
+    def test_subtype_based_pygments_lexer_match(self, httpbin):
+        """Test that media subtype is used if type/subtype doesn't
+        match any lexer.
+
+        """
+        env = MockEnvironment(colors=256)
+        r = http('--print=B', '--pretty=all', httpbin.url + '/post',
+                 'Content-Type:text/foo+json', 'a=b', env=env)
+        assert COLOR in r
+
+    def test_colors_option(self, httpbin):
+        env = MockEnvironment(colors=256)
+        r = http('--print=B', '--pretty=colors',
+                 'GET', httpbin.url + '/get', 'a=b',
+                 env=env)
+        # Tests that the JSON data isn't formatted.
+        assert not r.strip().count('\n')
+        assert COLOR in r
+
+    def test_format_option(self, httpbin):
+        env = MockEnvironment(colors=256)
+        r = http('--print=B', '--pretty=format',
+                 'GET', httpbin.url + '/get', 'a=b',
+                 env=env)
+        # Tests that the JSON data is formatted.
+        assert r.strip().count('\n') == 2
+        assert COLOR not in r
+
+
+class TestLineEndings:
+    """
+    Test that CRLF is properly used in headers
+    and as the headers/body separator.
+
+    """
+
+    def _validate_crlf(self, msg):
+        lines = iter(msg.splitlines(True))
+        for header in lines:
+            if header == CRLF:
+                break
+            assert header.endswith(CRLF), repr(header)
+        else:
+            assert 0, 'CRLF between headers and body not found in %r' % msg
+        body = ''.join(lines)
+        assert CRLF not in body
+        return body
+
+    def test_CRLF_headers_only(self, httpbin):
+        r = http('--headers', 'GET', httpbin.url + '/get')
+        body = self._validate_crlf(r)
+        assert not body, 'Garbage after headers: %r' % r
+
+    def test_CRLF_ugly_response(self, httpbin):
+        r = http('--pretty=none', 'GET', httpbin.url + '/get')
+        self._validate_crlf(r)
+
+    def test_CRLF_formatted_response(self, httpbin):
+        r = http('--pretty=format', 'GET', httpbin.url + '/get')
+        assert r.exit_status == ExitStatus.SUCCESS
+        self._validate_crlf(r)
+
+    def test_CRLF_ugly_request(self, httpbin):
+        r = http('--pretty=none', '--print=HB', 'GET', httpbin.url + '/get')
+        self._validate_crlf(r)
+
+    def test_CRLF_formatted_request(self, httpbin):
+        r = http('--pretty=format', '--print=HB', 'GET', httpbin.url + '/get')
+        self._validate_crlf(r)
+
+
+class TestFormatOptions:
+    def test_header_formatting_options(self):
+        def get_headers(sort):
+            return http(
+                '--offline', '--print=H',
+                '--format-options', 'headers.sort:' + sort,
+                'example.org', 'ZZZ:foo', 'XXX:foo',
+            )
+
+        r_sorted = get_headers('true')
+        r_unsorted = get_headers('false')
+        assert r_sorted != r_unsorted
+        assert f'XXX: foo{CRLF}ZZZ: foo' in r_sorted
+        assert f'ZZZ: foo{CRLF}XXX: foo' in r_unsorted
+
+    @pytest.mark.parametrize(
+        argnames=['options', 'expected_json'],
+        argvalues=[
+            # @formatter:off
+            (
+                'json.sort_keys:true,json.indent:4',
+                json.dumps({'a': 0, 'b': 0}, indent=4),
+            ),
+            (
+                'json.sort_keys:false,json.indent:2',
+                json.dumps({'b': 0, 'a': 0}, indent=2),
+            ),
+            (
+                'json.format:false',
+                json.dumps({'b': 0, 'a': 0}),
+            ),
+            # @formatter:on
+        ]
+    )
+    def test_json_formatting_options(self, options: str, expected_json: str):
+        r = http(
+            '--offline', '--print=B',
+            '--format-options', options,
+            'example.org', 'b:=0', 'a:=0',
+        )
+        assert expected_json in r
+
+    @pytest.mark.parametrize(
+        argnames=['defaults', 'options_string', 'expected'],
+        argvalues=[
+            # @formatter:off
+            ({'foo': {'bar': 1}}, 'foo.bar:2', {'foo': {'bar': 2}}),
+            ({'foo': {'bar': True}}, 'foo.bar:false', {'foo': {'bar': False}}),
+            ({'foo': {'bar': 'a'}}, 'foo.bar:b', {'foo': {'bar': 'b'}}),
+            # @formatter:on
+        ]
+    )
+    def test_parse_format_options(self, defaults, options_string, expected):
+        actual = parse_format_options(s=options_string, defaults=defaults)
+        assert expected == actual
+
+    @pytest.mark.parametrize(
+        argnames=['options_string', 'expected_error'],
+        argvalues=[
+            ('foo:2', 'invalid option'),
+            ('foo.baz:2', 'invalid key'),
+            ('foo.bar:false', 'expected int got bool'),
+        ]
+    )
+    def test_parse_format_options_errors(self, options_string, expected_error):
+        defaults = {
+            'foo': {
+                'bar': 1
+            }
+        }
+        with pytest.raises(argparse.ArgumentTypeError, match=expected_error):
+            parse_format_options(s=options_string, defaults=defaults)
+
+    @pytest.mark.parametrize(
+        argnames=['args', 'expected_format_options'],
+        argvalues=[
+            (
+                [
+                    '--format-options',
+                    'headers.sort:false,json.sort_keys:false',
+                    '--format-options=json.indent:10'
+                ],
+                {
+                    'headers': {
+                        'sort': False
+                    },
+                    'json': {
+                        'sort_keys': False,
+                        'indent': 10,
+                        'format': True
+                    },
+                }
+            ),
+            (
+                [
+                    '--unsorted'
+                ],
+                {
+                    'headers': {
+                        'sort': False
+                    },
+                    'json': {
+                        'sort_keys': False,
+                        'indent': 4,
+                        'format': True
+                    },
+                }
+            ),
+            (
+                [
+                    '--format-options=headers.sort:true',
+                    '--unsorted',
+                    '--format-options=headers.sort:true',
+                ],
+                {
+                    'headers': {
+                        'sort': True
+                    },
+                    'json': {
+                        'sort_keys': False,
+                        'indent': 4,
+                        'format': True
+                    },
+                }
+            ),
+            (
+                [
+                    '--no-format-options',  # --no-<option> anywhere resets
+                    '--format-options=headers.sort:true',
+                    '--unsorted',
+                    '--format-options=headers.sort:true',
+                ],
+                PARSED_DEFAULT_FORMAT_OPTIONS,
+            ),
+            (
+                [
+                    '--format-options=json.indent:2',
+                    '--unsorted',
+                    '--no-unsorted',
+                ],
+                {
+                    'headers': {
+                        'sort': True
+                    },
+                    'json': {
+                        'sort_keys': True,
+                        'indent': 2,
+                        'format': True
+                    },
+                }
+            ),
+            (
+                [
+                    '--format-options=json.indent:2',
+                    '--unsorted',
+                    '--sorted',
+                ],
+                {
+                    'headers': {
+                        'sort': True
+                    },
+                    'json': {
+                        'sort_keys': True,
+                        'indent': 2,
+                        'format': True
+                    },
+                }
+            ),
+            (
+                [
+                    '--format-options=json.indent:2',
+                    '--sorted',
+                    '--no-sorted',
+                    '--no-unsorted',
+                ],
+                {
+                    'headers': {
+                        'sort': True
+                    },
+                    'json': {
+                        'sort_keys': True,
+                        'indent': 2,
+                        'format': True
+                    },
+                }
+            ),
+        ],
+    )
+    def test_format_options_accumulation(self, args, expected_format_options):
+        parsed_args = parser.parse_args(
+            args=[*args, 'example.org'],
+            env=MockEnvironment(),
+        )
+        assert parsed_args.format_options == expected_format_options

tests/test_redirects.py

@@ -0,0 +1,52 @@
+"""High-level tests."""
+import pytest
+
+from httpie.status import ExitStatus
+from utils import http, HTTP_OK
+
+
+def test_follow_all_redirects_shown(httpbin):
+    r = http('--follow', '--all', httpbin.url + '/redirect/2')
+    assert r.count('HTTP/1.1') == 3
+    assert r.count('HTTP/1.1 302 FOUND', 2)
+    assert HTTP_OK in r
+
+
+@pytest.mark.parametrize('follow_flag', ['--follow', '-F'])
+def test_follow_without_all_redirects_hidden(httpbin, follow_flag):
+    r = http(follow_flag, httpbin.url + '/redirect/2')
+    assert r.count('HTTP/1.1') == 1
+    assert HTTP_OK in r
+
+
+def test_follow_all_output_options_used_for_redirects(httpbin):
+    r = http('--check-status',
+             '--follow',
+             '--all',
+             '--print=H',
+             httpbin.url + '/redirect/2')
+    assert r.count('GET /') == 3
+    assert HTTP_OK not in r
+
+#
+# def test_follow_redirect_output_options(httpbin):
+#     r = http('--check-status',
+#              '--follow',
+#              '--all',
+#              '--print=h',
+#              '--history-print=H',
+#              httpbin.url + '/redirect/2')
+#     assert r.count('GET /') == 2
+#     assert 'HTTP/1.1 302 FOUND' not in r
+#     assert HTTP_OK in r
+#
+
+
+def test_max_redirects(httpbin):
+    r = http(
+        '--max-redirects=1',
+        '--follow',
+        httpbin.url + '/redirect/3',
+        tolerate_error_exit_status=True,
+    )
+    assert r.exit_status == ExitStatus.ERROR_TOO_MANY_REDIRECTS

tests/test_regressions.py

@@ -0,0 +1,27 @@
+"""Miscellaneous regression tests"""
+import pytest
+
+from utils import http, HTTP_OK
+from httpie.compat import is_windows
+
+
+def test_Host_header_overwrite(httpbin):
+    """
+    https://github.com/jakubroztocil/httpie/issues/235
+
+    """
+    host = 'httpbin.org'
+    url = httpbin.url + '/get'
+    r = http('--print=hH', url, 'host:{0}'.format(host))
+    assert HTTP_OK in r
+    assert r.lower().count('host:') == 1
+    assert 'host: {0}'.format(host) in r
+
+
+@pytest.mark.skipif(is_windows, reason='Unix-only')
+def test_output_devnull(httpbin):
+    """
+    https://github.com/jakubroztocil/httpie/issues/252
+
+    """
+    http('--output=/dev/null', httpbin + '/get')

tests/test_sessions.py

@@ -0,0 +1,476 @@
+# coding=utf-8
+import json
+import os
+import shutil
+from datetime import datetime
+from mock import mock
+from tempfile import gettempdir
+
+import pytest
+
+from fixtures import UNICODE
+from httpie.plugins import AuthPlugin
+from httpie.plugins.builtin import HTTPBasicAuth
+from httpie.plugins.registry import plugin_manager
+from httpie.sessions import Session
+from httpie.utils import get_expired_cookies
+from tests.test_auth_plugins import basic_auth
+from utils import HTTP_OK, MockEnvironment, http, mk_config_dir
+
+
+class SessionTestBase:
+
+    def start_session(self, httpbin):
+        """Create and reuse a unique config dir for each test."""
+        self.config_dir = mk_config_dir()
+
+    def teardown_method(self, method):
+        shutil.rmtree(self.config_dir)
+
+    def env(self):
+        """
+        Return an environment.
+
+        Each environment created within a test method
+        will share the same config_dir. It is necessary
+        for session files being reused.
+
+        """
+        return MockEnvironment(config_dir=self.config_dir)
+
+
+class CookieTestBase:
+    def setup_method(self, method):
+        self.config_dir = mk_config_dir()
+
+        orig_session = {
+            'cookies': {
+                'cookie1': {
+                    'value': 'foo',
+                },
+                'cookie2': {
+                    'value': 'foo',
+                }
+            }
+        }
+        self.session_path = self.config_dir / 'test-session.json'
+        self.session_path.write_text(json.dumps(orig_session))
+
+    def teardown_method(self, method):
+        shutil.rmtree(self.config_dir)
+
+
+class TestSessionFlow(SessionTestBase):
+    """
+    These tests start with an existing session created in `setup_method()`.
+
+    """
+
+    def start_session(self, httpbin):
+        """
+        Start a full-blown session with a custom request header,
+        authorization, and response cookies.
+
+        """
+        super().start_session(httpbin)
+        r1 = http(
+            '--follow',
+            '--session=test',
+            '--auth=username:password',
+            'GET',
+            httpbin.url + '/cookies/set?hello=world',
+            'Hello:World',
+            env=self.env()
+        )
+        assert HTTP_OK in r1
+
+    def test_session_created_and_reused(self, httpbin):
+        self.start_session(httpbin)
+        # Verify that the session created in setup_method() has been used.
+        r2 = http('--session=test',
+                  'GET', httpbin.url + '/get', env=self.env())
+        assert HTTP_OK in r2
+        assert r2.json['headers']['Hello'] == 'World'
+        assert r2.json['headers']['Cookie'] == 'hello=world'
+        assert 'Basic ' in r2.json['headers']['Authorization']
+
+    def test_session_update(self, httpbin):
+        self.start_session(httpbin)
+        # Get a response to a request from the original session.
+        r2 = http('--session=test', 'GET', httpbin.url + '/get',
+                  env=self.env())
+        assert HTTP_OK in r2
+
+        # Make a request modifying the session data.
+        r3 = http('--follow', '--session=test', '--auth=username:password2',
+                  'GET', httpbin.url + '/cookies/set?hello=world2',
+                  'Hello:World2',
+                  env=self.env())
+        assert HTTP_OK in r3
+
+        # Get a response to a request from the updated session.
+        r4 = http('--session=test', 'GET', httpbin.url + '/get',
+                  env=self.env())
+        assert HTTP_OK in r4
+        assert r4.json['headers']['Hello'] == 'World2'
+        assert r4.json['headers']['Cookie'] == 'hello=world2'
+        assert (r2.json['headers']['Authorization']
+                != r4.json['headers']['Authorization'])
+
+    def test_session_read_only(self, httpbin):
+        self.start_session(httpbin)
+        # Get a response from the original session.
+        r2 = http('--session=test', 'GET', httpbin.url + '/get',
+                  env=self.env())
+        assert HTTP_OK in r2
+
+        # Make a request modifying the session data but
+        # with --session-read-only.
+        r3 = http('--follow', '--session-read-only=test',
+                  '--auth=username:password2', 'GET',
+                  httpbin.url + '/cookies/set?hello=world2', 'Hello:World2',
+                  env=self.env())
+        assert HTTP_OK in r3
+
+        # Get a response from the updated session.
+        r4 = http('--session=test', 'GET', httpbin.url + '/get',
+                  env=self.env())
+        assert HTTP_OK in r4
+
+        # Origin can differ on Travis.
+        del r2.json['origin'], r4.json['origin']
+        # Different for each request.
+
+        # Should be the same as before r3.
+        assert r2.json == r4.json
+
+
+class TestSession(SessionTestBase):
+    """Stand-alone session tests."""
+
+    def test_session_ignored_header_prefixes(self, httpbin):
+        self.start_session(httpbin)
+        r1 = http('--session=test', 'GET', httpbin.url + '/get',
+                  'Content-Type: text/plain',
+                  'If-Unmodified-Since: Sat, 29 Oct 1994 19:43:31 GMT',
+                  env=self.env())
+        assert HTTP_OK in r1
+        r2 = http('--session=test', 'GET', httpbin.url + '/get',
+                  env=self.env())
+        assert HTTP_OK in r2
+        assert 'Content-Type' not in r2.json['headers']
+        assert 'If-Unmodified-Since' not in r2.json['headers']
+
+    def test_session_by_path(self, httpbin):
+        self.start_session(httpbin)
+        session_path = self.config_dir / 'session-by-path.json'
+        r1 = http('--session', str(session_path), 'GET', httpbin.url + '/get',
+                  'Foo:Bar', env=self.env())
+        assert HTTP_OK in r1
+
+        r2 = http('--session', str(session_path), 'GET', httpbin.url + '/get',
+                  env=self.env())
+        assert HTTP_OK in r2
+        assert r2.json['headers']['Foo'] == 'Bar'
+
+    def test_session_unicode(self, httpbin):
+        self.start_session(httpbin)
+
+        r1 = http('--session=test', u'--auth=test:' + UNICODE,
+                  'GET', httpbin.url + '/get', u'Test:%s' % UNICODE,
+                  env=self.env())
+        assert HTTP_OK in r1
+
+        r2 = http('--session=test', '--verbose', 'GET',
+                  httpbin.url + '/get', env=self.env())
+        assert HTTP_OK in r2
+
+        # FIXME: Authorization *sometimes* is not present on Python3
+        assert (r2.json['headers']['Authorization']
+                == HTTPBasicAuth.make_header(u'test', UNICODE))
+        # httpbin doesn't interpret utf8 headers
+        assert UNICODE in r2
+
+    def test_session_default_header_value_overwritten(self, httpbin):
+        self.start_session(httpbin)
+        # https://github.com/jakubroztocil/httpie/issues/180
+        r1 = http('--session=test',
+                  httpbin.url + '/headers', 'User-Agent:custom',
+                  env=self.env())
+        assert HTTP_OK in r1
+        assert r1.json['headers']['User-Agent'] == 'custom'
+
+        r2 = http('--session=test', httpbin.url + '/headers', env=self.env())
+        assert HTTP_OK in r2
+        assert r2.json['headers']['User-Agent'] == 'custom'
+
+    def test_download_in_session(self, httpbin):
+        # https://github.com/jakubroztocil/httpie/issues/412
+        self.start_session(httpbin)
+        cwd = os.getcwd()
+        os.chdir(gettempdir())
+        try:
+            http('--session=test', '--download',
+                 httpbin.url + '/get', env=self.env())
+        finally:
+            os.chdir(cwd)
+
+    @pytest.mark.parametrize(
+        argnames=['auth_require_param', 'auth_parse_param'],
+        argvalues=[
+            (False, False),
+            (False, True),
+            (True, False)
+        ]
+    )
+    def test_auth_type_reused_in_session(self, auth_require_param, auth_parse_param, httpbin):
+        self.start_session(httpbin)
+        session_path = self.config_dir / 'test-session.json'
+
+        header = 'Custom dXNlcjpwYXNzd29yZA'
+
+        class Plugin(AuthPlugin):
+            auth_type = 'test-reused'
+            auth_require = auth_require_param
+            auth_parse = auth_parse_param
+
+            def get_auth(self, username=None, password=None):
+                return basic_auth(header=f'{header}==')
+
+        plugin_manager.register(Plugin)
+
+        r1 = http(
+            '--session', str(session_path),
+            httpbin + '/basic-auth/user/password',
+            '--auth-type',
+            Plugin.auth_type,
+            '--auth', 'user:password',
+            '--print=H',
+        )
+
+        r2 = http(
+            '--session', str(session_path),
+            httpbin + '/basic-auth/user/password',
+            '--print=H',
+        )
+        assert f'Authorization: {header}' in r1
+        assert f'Authorization: {header}' in r2
+        plugin_manager.unregister(Plugin)
+
+    @mock.patch('httpie.cli.argtypes.AuthCredentials._getpass',
+                new=lambda self, prompt: 'password')
+    def test_auth_plugin_prompt_password_in_session(self, httpbin):
+        self.start_session(httpbin)
+        session_path = self.config_dir / 'test-session.json'
+
+        class Plugin(AuthPlugin):
+            auth_type = 'test-prompted'
+
+            def get_auth(self, username=None, password=None):
+                return basic_auth()
+
+        plugin_manager.register(Plugin)
+
+        r1 = http(
+            '--session', str(session_path),
+            httpbin + '/basic-auth/user/password',
+            '--auth-type',
+            Plugin.auth_type,
+            '--auth', 'user:',
+        )
+
+        r2 = http(
+            '--session', str(session_path),
+            httpbin + '/basic-auth/user/password',
+        )
+        assert HTTP_OK in r1
+        assert HTTP_OK in r2
+        plugin_manager.unregister(Plugin)
+
+    def test_auth_type_stored_in_session_file(self, httpbin):
+        self.config_dir = mk_config_dir()
+        self.session_path = self.config_dir / 'test-session.json'
+
+        class Plugin(AuthPlugin):
+            auth_type = 'test-saved'
+            auth_require = True
+
+            def get_auth(self, username=None, password=None):
+                return basic_auth()
+
+        plugin_manager.register(Plugin)
+        http('--session', str(self.session_path),
+             httpbin + '/basic-auth/user/password',
+             '--auth-type',
+             Plugin.auth_type,
+             '--auth', 'user:password',
+             )
+        updated_session = json.loads(self.session_path.read_text())
+        assert updated_session['auth']['type'] == 'test-saved'
+        assert updated_session['auth']['raw_auth'] == "user:password"
+        plugin_manager.unregister(Plugin)
+
+
+class TestExpiredCookies(CookieTestBase):
+
+    @pytest.mark.parametrize(
+        argnames=['initial_cookie', 'expired_cookie'],
+        argvalues=[
+            ({'id': {'value': 123}}, 'id'),
+            ({'id': {'value': 123}}, 'token')
+        ]
+    )
+    def test_removes_expired_cookies_from_session_obj(self, initial_cookie, expired_cookie, httpbin):
+        session = Session(self.config_dir)
+        session['cookies'] = initial_cookie
+        session.remove_cookies([expired_cookie])
+        assert expired_cookie not in session.cookies
+
+    def test_expired_cookies(self, httpbin):
+        r = http(
+            '--session', str(self.session_path),
+            '--print=H',
+            httpbin.url + '/cookies/delete?cookie2',
+        )
+        assert 'Cookie: cookie1=foo; cookie2=foo' in r
+
+        updated_session = json.loads(self.session_path.read_text())
+        assert 'cookie1' in updated_session['cookies']
+        assert 'cookie2' not in updated_session['cookies']
+
+    @pytest.mark.parametrize(
+        argnames=['headers', 'now', 'expected_expired'],
+        argvalues=[
+            (
+                [
+                    ('Set-Cookie', 'hello=world; Path=/; Expires=Thu, 01-Jan-1970 00:00:00 GMT; HttpOnly'),
+                    ('Connection', 'keep-alive')
+                ],
+                None,
+                [
+                    {
+                        'name': 'hello',
+                        'path': '/'
+                    }
+                ]
+            ),
+            (
+                [
+                    ('Set-Cookie', 'hello=world; Path=/; Expires=Thu, 01-Jan-1970 00:00:00 GMT; HttpOnly'),
+                    ('Set-Cookie', 'pea=pod; Path=/ab; Expires=Thu, 01-Jan-1970 00:00:00 GMT; HttpOnly'),
+                    ('Connection', 'keep-alive')
+                ],
+                None,
+                [
+                    {'name': 'hello', 'path': '/'},
+                    {'name': 'pea', 'path': '/ab'}
+                ]
+            ),
+            (
+                # Checks we gracefully ignore expires date in invalid format.
+                # <https://github.com/httpie/httpie/issues/963>
+                [
+                    ('Set-Cookie', 'pfg=; Expires=Sat, 19-Sep-2020 06:58:14 GMT+0000; Max-Age=0; path=/; domain=.tumblr.com; secure; HttpOnly'),
+                ],
+                None,
+                []
+            ),
+            (
+                [
+                    ('Set-Cookie', 'hello=world; Path=/; Expires=Fri, 12 Jun 2020 12:28:55 GMT; HttpOnly'),
+                    ('Connection', 'keep-alive')
+                ],
+                datetime(2020, 6, 11).timestamp(),
+                []
+            ),
+        ]
+    )
+    def test_get_expired_cookies_manages_multiple_cookie_headers(self, headers, now, expected_expired):
+        assert get_expired_cookies(headers, now=now) == expected_expired
+
+
+class TestCookieStorage(CookieTestBase):
+
+    @pytest.mark.parametrize(
+        argnames=['new_cookies', 'new_cookies_dict', 'expected'],
+        argvalues=[(
+            'new=bar',
+            {'new': 'bar'},
+            'cookie1=foo; cookie2=foo; new=bar'
+        ),
+            (
+            'new=bar;chocolate=milk',
+            {'new': 'bar', 'chocolate': 'milk'},
+            'chocolate=milk; cookie1=foo; cookie2=foo; new=bar'
+        ),
+            (
+            'new=bar; chocolate=milk',
+            {'new': 'bar', 'chocolate': 'milk'},
+            'chocolate=milk; cookie1=foo; cookie2=foo; new=bar'
+        ),
+            (
+            'new=bar;; chocolate=milk;;;',
+            {'new': 'bar', 'chocolate': 'milk'},
+            'cookie1=foo; cookie2=foo; new=bar'
+        ),
+            (
+            'new=bar; chocolate=milk;;;',
+            {'new': 'bar', 'chocolate': 'milk'},
+            'chocolate=milk; cookie1=foo; cookie2=foo; new=bar'
+        )
+        ]
+    )
+    def test_existing_and_new_cookies_sent_in_request(self, new_cookies, new_cookies_dict, expected, httpbin):
+        r = http(
+            '--session', str(self.session_path),
+            '--print=H',
+            httpbin.url,
+            'Cookie:' + new_cookies,
+        )
+        # Note: cookies in response are in alphabetical order
+        assert 'Cookie: ' + expected in r
+
+        updated_session = json.loads(self.session_path.read_text())
+        for name, value in new_cookies_dict.items():
+            assert name, value in updated_session['cookies']
+            assert 'Cookie' not in updated_session['headers']
+
+    @pytest.mark.parametrize(
+        argnames=['cli_cookie', 'set_cookie', 'expected'],
+        argvalues=[(
+            '',
+            '/cookies/set/cookie1/bar',
+            'bar'
+        ),
+            (
+            'cookie1=not_foo',
+            '/cookies/set/cookie1/bar',
+            'bar'
+        ),
+            (
+            'cookie1=not_foo',
+            '',
+            'not_foo'
+        ),
+            (
+            '',
+            '',
+            'foo'
+        )
+        ]
+    )
+    def test_cookie_storage_priority(self, cli_cookie, set_cookie, expected, httpbin):
+        """
+        Expected order of priority for cookie storage in session file:
+        1. set-cookie (from server)
+        2. command line arg
+        3. cookie already stored in session file
+        """
+        r = http(
+            '--session', str(self.session_path),
+            httpbin.url + set_cookie,
+            'Cookie:' + cli_cookie,
+        )
+        updated_session = json.loads(self.session_path.read_text())
+
+        assert updated_session['cookies']['cookie1']['value'] == expected

tests/test_ssl.py

@@ -0,0 +1,151 @@
+import pytest
+import pytest_httpbin.certs
+import requests.exceptions
+import ssl
+import urllib3
+
+from httpie.ssl import AVAILABLE_SSL_VERSION_ARG_MAPPING, DEFAULT_SSL_CIPHERS
+from httpie.status import ExitStatus
+from utils import HTTP_OK, TESTS_ROOT, http
+
+
+try:
+    # Handle OpenSSL errors, if installed.
+    # See <https://github.com/jakubroztocil/httpie/issues/729>
+    # noinspection PyUnresolvedReferences
+    import OpenSSL.SSL
+    ssl_errors = (
+        requests.exceptions.SSLError,
+        OpenSSL.SSL.Error,
+    )
+except ImportError:
+    ssl_errors = (
+        requests.exceptions.SSLError,
+    )
+
+CERTS_ROOT = TESTS_ROOT / 'client_certs'
+CLIENT_CERT = str(CERTS_ROOT / 'client.crt')
+CLIENT_KEY = str(CERTS_ROOT / 'client.key')
+CLIENT_PEM = str(CERTS_ROOT / 'client.pem')
+
+
+# We test against a local httpbin instance which uses a self-signed cert.
+# Requests without --verify=<CA_BUNDLE> will fail with a verification error.
+# See: https://github.com/kevin1024/pytest-httpbin#https-support
+CA_BUNDLE = pytest_httpbin.certs.where()
+
+
+@pytest.mark.parametrize('ssl_version',
+                         AVAILABLE_SSL_VERSION_ARG_MAPPING.keys())
+def test_ssl_version(httpbin_secure, ssl_version):
+    try:
+        r = http(
+            '--ssl', ssl_version,
+            httpbin_secure + '/get'
+        )
+        assert HTTP_OK in r
+    except ssl_errors as e:
+        if ssl_version == 'ssl3':
+            # pytest-httpbin doesn't support ssl3
+            pass
+        elif e.__context__ is not None:  # Check if root cause was an unsupported TLS version
+            root = e.__context__
+            while root.__context__ is not None:
+                root = root.__context__
+            if isinstance(root, ssl.SSLError) and root.reason == "TLSV1_ALERT_PROTOCOL_VERSION":
+                pytest.skip("Unsupported TLS version: {}".format(ssl_version))
+        else:
+            raise
+
+
+class TestClientCert:
+
+    def test_cert_and_key(self, httpbin_secure):
+        r = http(httpbin_secure + '/get',
+                 '--cert', CLIENT_CERT,
+                 '--cert-key', CLIENT_KEY)
+        assert HTTP_OK in r
+
+    def test_cert_pem(self, httpbin_secure):
+        r = http(httpbin_secure + '/get',
+                 '--cert', CLIENT_PEM)
+        assert HTTP_OK in r
+
+    def test_cert_file_not_found(self, httpbin_secure):
+        r = http(httpbin_secure + '/get',
+                 '--cert', '/__not_found__',
+                 tolerate_error_exit_status=True)
+        assert r.exit_status == ExitStatus.ERROR
+        assert 'No such file or directory' in r.stderr
+
+    def test_cert_file_invalid(self, httpbin_secure):
+        with pytest.raises(ssl_errors):
+            http(httpbin_secure + '/get',
+                 '--cert', __file__)
+
+    def test_cert_ok_but_missing_key(self, httpbin_secure):
+        with pytest.raises(ssl_errors):
+            http(httpbin_secure + '/get',
+                 '--cert', CLIENT_CERT)
+
+
+class TestServerCert:
+
+    def test_verify_no_OK(self, httpbin_secure):
+        # Avoid warnings when explicitly testing insecure requests
+        urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+        r = http(httpbin_secure.url + '/get', '--verify=no')
+        assert HTTP_OK in r
+
+    @pytest.mark.parametrize('verify_value', ['false', 'fALse'])
+    def test_verify_false_OK(self, httpbin_secure, verify_value):
+        urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+        r = http(httpbin_secure.url + '/get', '--verify', verify_value)
+        assert HTTP_OK in r
+
+    def test_verify_custom_ca_bundle_path(
+        self, httpbin_secure_untrusted
+    ):
+        r = http(httpbin_secure_untrusted + '/get', '--verify', CA_BUNDLE)
+        assert HTTP_OK in r
+
+    def test_self_signed_server_cert_by_default_raises_ssl_error(
+        self,
+        httpbin_secure_untrusted
+    ):
+        with pytest.raises(ssl_errors):
+            http(httpbin_secure_untrusted.url + '/get')
+
+    def test_verify_custom_ca_bundle_invalid_path(self, httpbin_secure):
+        # since 2.14.0 requests raises IOError
+        with pytest.raises(ssl_errors + (IOError,)):
+            http(httpbin_secure.url + '/get', '--verify', '/__not_found__')
+
+    def test_verify_custom_ca_bundle_invalid_bundle(self, httpbin_secure):
+        with pytest.raises(ssl_errors):
+            http(httpbin_secure.url + '/get', '--verify', __file__)
+
+
+def test_ciphers(httpbin_secure):
+    r = http(
+        httpbin_secure.url + '/get',
+        '--ciphers',
+        DEFAULT_SSL_CIPHERS,
+    )
+    assert HTTP_OK in r
+
+
+def test_ciphers_none_can_be_selected(httpbin_secure):
+    r = http(
+        httpbin_secure.url + '/get',
+        '--ciphers',
+        '__FOO__',
+        tolerate_error_exit_status=True,
+    )
+    assert r.exit_status == ExitStatus.ERROR
+    # Linux/macOS:
+    #   http: error: SSLError: ('No cipher can be selected.',)
+    # OpenBSD:
+    #   <https://marc.info/?l=openbsd-ports&m=159251948515635&w=2>
+    #   http: error: Error: [('SSL routines', '(UNKNOWN)SSL_internal', 'no cipher match')]
+    assert 'cipher' in r.stderr

tests/test_stream.py

@@ -0,0 +1,49 @@
+import pytest
+
+from httpie.compat import is_windows
+from httpie.output.streams import BINARY_SUPPRESSED_NOTICE
+from utils import StdinBytesIO, http, MockEnvironment
+from fixtures import BIN_FILE_CONTENT, BIN_FILE_PATH
+
+
+# GET because httpbin 500s with binary POST body.
+
+
+@pytest.mark.skipif(is_windows,
+                    reason='Pretty redirect not supported under Windows')
+def test_pretty_redirected_stream(httpbin):
+    """Test that --stream works with prettified redirected output."""
+    env = MockEnvironment(
+        colors=256,
+        stdin=StdinBytesIO(BIN_FILE_PATH.read_bytes()),
+        stdin_isatty=False,
+        stdout_isatty=False,
+    )
+    r = http('--verbose', '--pretty=all', '--stream', 'GET',
+             httpbin.url + '/get', env=env)
+    assert BINARY_SUPPRESSED_NOTICE.decode() in r
+
+
+def test_encoded_stream(httpbin):
+    """Test that --stream works with non-prettified
+    redirected terminal output."""
+    env = MockEnvironment(
+        stdin=StdinBytesIO(BIN_FILE_PATH.read_bytes()),
+        stdin_isatty=False,
+    )
+    r = http('--pretty=none', '--stream', '--verbose', 'GET',
+             httpbin.url + '/get', env=env)
+    assert BINARY_SUPPRESSED_NOTICE.decode() in r
+
+
+def test_redirected_stream(httpbin):
+    """Test that --stream works with non-prettified
+    redirected terminal output."""
+    env = MockEnvironment(
+        stdout_isatty=False,
+        stdin_isatty=False,
+        stdin=StdinBytesIO(BIN_FILE_PATH.read_bytes()),
+    )
+    r = http('--pretty=none', '--stream', '--verbose', 'GET',
+             httpbin.url + '/get', env=env)
+    assert BIN_FILE_CONTENT in r

tests/test_unicode.py

@@ -0,0 +1,97 @@
+# coding=utf-8
+"""
+Various unicode handling related tests.
+
+"""
+from utils import http, HTTP_OK
+from fixtures import UNICODE
+
+
+def test_unicode_headers(httpbin):
+    # httpbin doesn't interpret utf8 headers
+    r = http(httpbin.url + '/headers', u'Test:%s' % UNICODE)
+    assert HTTP_OK in r
+
+
+def test_unicode_headers_verbose(httpbin):
+    # httpbin doesn't interpret utf8 headers
+    r = http('--verbose', httpbin.url + '/headers', u'Test:%s' % UNICODE)
+    assert HTTP_OK in r
+    assert UNICODE in r
+
+
+def test_unicode_form_item(httpbin):
+    r = http('--form', 'POST', httpbin.url + '/post', u'test=%s' % UNICODE)
+    assert HTTP_OK in r
+    assert r.json['form'] == {'test': UNICODE}
+
+
+def test_unicode_form_item_verbose(httpbin):
+    r = http('--verbose', '--form',
+             'POST', httpbin.url + '/post', u'test=%s' % UNICODE)
+    assert HTTP_OK in r
+    assert UNICODE in r
+
+
+def test_unicode_json_item(httpbin):
+    r = http('--json', 'POST', httpbin.url + '/post', u'test=%s' % UNICODE)
+    assert HTTP_OK in r
+    assert r.json['json'] == {'test': UNICODE}
+
+
+def test_unicode_json_item_verbose(httpbin):
+    r = http('--verbose', '--json',
+             'POST', httpbin.url + '/post', u'test=%s' % UNICODE)
+    assert HTTP_OK in r
+    assert UNICODE in r
+
+
+def test_unicode_raw_json_item(httpbin):
+    r = http('--json', 'POST', httpbin.url + '/post',
+             u'test:={ "%s" : [ "%s" ] }' % (UNICODE, UNICODE))
+    assert HTTP_OK in r
+    assert r.json['json'] == {'test': {UNICODE: [UNICODE]}}
+
+
+def test_unicode_raw_json_item_verbose(httpbin):
+    r = http('--json', 'POST', httpbin.url + '/post',
+             u'test:={ "%s" : [ "%s" ] }' % (UNICODE, UNICODE))
+    assert HTTP_OK in r
+    assert r.json['json'] == {'test': {UNICODE: [UNICODE]}}
+
+
+def test_unicode_url_query_arg_item(httpbin):
+    r = http(httpbin.url + '/get', u'test==%s' % UNICODE)
+    assert HTTP_OK in r
+    assert r.json['args'] == {'test': UNICODE}, r
+
+
+def test_unicode_url_query_arg_item_verbose(httpbin):
+    r = http('--verbose', httpbin.url + '/get', u'test==%s' % UNICODE)
+    assert HTTP_OK in r
+    assert UNICODE in r
+
+
+def test_unicode_url(httpbin):
+    r = http(httpbin.url + u'/get?test=' + UNICODE)
+    assert HTTP_OK in r
+    assert r.json['args'] == {'test': UNICODE}
+
+# def test_unicode_url_verbose(self):
+#     r = http(httpbin.url + '--verbose', u'/get?test=' + UNICODE)
+#     assert HTTP_OK in r
+
+
+def test_unicode_basic_auth(httpbin):
+    # it doesn't really authenticate us because httpbin
+    # doesn't interpret the utf8-encoded auth
+    http('--verbose', '--auth', u'test:%s' % UNICODE,
+         httpbin.url + u'/basic-auth/test/' + UNICODE)
+
+
+def test_unicode_digest_auth(httpbin):
+    # it doesn't really authenticate us because httpbin
+    # doesn't interpret the utf8-encoded auth
+    http('--auth-type=digest',
+         '--auth', u'test:%s' % UNICODE,
+         httpbin.url + u'/digest-auth/auth/test/' + UNICODE)

tests/test_uploads.py

@@ -0,0 +1,255 @@
+import os
+
+import pytest
+
+from httpie.cli.exceptions import ParseError
+from httpie.client import FORM_CONTENT_TYPE
+from httpie.status import ExitStatus
+from utils import (
+    HTTPBIN_WITH_CHUNKED_SUPPORT, MockEnvironment, StdinBytesIO, http,
+    HTTP_OK,
+)
+from fixtures import FILE_PATH_ARG, FILE_PATH, FILE_CONTENT
+
+
+def test_chunked_json():
+    r = http(
+        '--verbose',
+        '--chunked',
+        HTTPBIN_WITH_CHUNKED_SUPPORT + '/post',
+        'hello=world',
+    )
+    assert HTTP_OK in r
+    assert 'Transfer-Encoding: chunked' in r
+    assert r.count('hello') == 3
+
+
+def test_chunked_form():
+    r = http(
+        '--verbose',
+        '--chunked',
+        '--form',
+        HTTPBIN_WITH_CHUNKED_SUPPORT + '/post',
+        'hello=world',
+    )
+    assert HTTP_OK in r
+    assert 'Transfer-Encoding: chunked' in r
+    assert r.count('hello') == 2
+
+
+def test_chunked_stdin():
+    r = http(
+        '--verbose',
+        '--chunked',
+        HTTPBIN_WITH_CHUNKED_SUPPORT + '/post',
+        env=MockEnvironment(
+            stdin=StdinBytesIO(FILE_PATH.read_bytes()),
+            stdin_isatty=False,
+        )
+    )
+    assert HTTP_OK in r
+    assert 'Transfer-Encoding: chunked' in r
+    assert r.count(FILE_CONTENT) == 2
+
+
+class TestMultipartFormDataFileUpload:
+
+    def test_non_existent_file_raises_parse_error(self, httpbin):
+        with pytest.raises(ParseError):
+            http('--form',
+                 'POST', httpbin.url + '/post', 'foo@/__does_not_exist__')
+
+    def test_upload_ok(self, httpbin):
+        r = http('--form', '--verbose', 'POST', httpbin.url + '/post',
+                 f'test-file@{FILE_PATH_ARG}', 'foo=bar')
+        assert HTTP_OK in r
+        assert 'Content-Disposition: form-data; name="foo"' in r
+        assert 'Content-Disposition: form-data; name="test-file";' \
+               f' filename="{os.path.basename(FILE_PATH)}"' in r
+        assert FILE_CONTENT in r
+        assert '"foo": "bar"' in r
+        assert 'Content-Type: text/plain' in r
+
+    def test_upload_multiple_fields_with_the_same_name(self, httpbin):
+        r = http('--form', '--verbose', 'POST', httpbin.url + '/post',
+                 f'test-file@{FILE_PATH_ARG}',
+                 f'test-file@{FILE_PATH_ARG}')
+        assert HTTP_OK in r
+        assert r.count('Content-Disposition: form-data; name="test-file";'
+                       f' filename="{os.path.basename(FILE_PATH)}"') == 2
+        # Should be 4, but is 3 because httpbin
+        # doesn't seem to support filed field lists
+        assert r.count(FILE_CONTENT) in [3, 4]
+        assert r.count('Content-Type: text/plain') == 2
+
+    def test_upload_custom_content_type(self, httpbin):
+        r = http(
+            '--form',
+            '--verbose',
+            httpbin.url + '/post',
+            f'test-file@{FILE_PATH_ARG};type=image/vnd.microsoft.icon'
+        )
+        assert HTTP_OK in r
+        # Content type is stripped from the filename
+        assert 'Content-Disposition: form-data; name="test-file";' \
+               f' filename="{os.path.basename(FILE_PATH)}"' in r
+        assert r.count(FILE_CONTENT) == 2
+        assert 'Content-Type: image/vnd.microsoft.icon' in r
+
+    def test_form_no_files_urlencoded(self, httpbin):
+        r = http(
+            '--form',
+            '--verbose',
+            httpbin.url + '/post',
+            'AAAA=AAA',
+            'BBB=BBB',
+        )
+        assert HTTP_OK in r
+        assert FORM_CONTENT_TYPE in r
+
+    def test_multipart(self, httpbin):
+        r = http(
+            '--verbose',
+            '--multipart',
+            httpbin.url + '/post',
+            'AAAA=AAA',
+            'BBB=BBB',
+        )
+        assert HTTP_OK in r
+        assert FORM_CONTENT_TYPE not in r
+        assert 'multipart/form-data' in r
+
+    def test_form_multipart_custom_boundary(self, httpbin):
+        boundary = 'HTTPIE_FTW'
+        r = http(
+            '--print=HB',
+            '--check-status',
+            '--multipart',
+            f'--boundary={boundary}',
+            httpbin.url + '/post',
+            'AAAA=AAA',
+            'BBB=BBB',
+        )
+        assert f'multipart/form-data; boundary={boundary}' in r
+        assert r.count(boundary) == 4
+
+    def test_multipart_custom_content_type_boundary_added(self, httpbin):
+        boundary = 'HTTPIE_FTW'
+        r = http(
+            '--print=HB',
+            '--check-status',
+            '--multipart',
+            f'--boundary={boundary}',
+            httpbin.url + '/post',
+            'Content-Type: multipart/magic',
+            'AAAA=AAA',
+            'BBB=BBB',
+        )
+        assert f'multipart/magic; boundary={boundary}' in r
+        assert r.count(boundary) == 4
+
+    def test_multipart_custom_content_type_boundary_preserved(self, httpbin):
+        # Allow explicit nonsense requests.
+        boundary_in_header = 'HEADER_BOUNDARY'
+        boundary_in_body = 'BODY_BOUNDARY'
+        r = http(
+            '--print=HB',
+            '--check-status',
+            '--multipart',
+            f'--boundary={boundary_in_body}',
+            httpbin.url + '/post',
+            f'Content-Type: multipart/magic; boundary={boundary_in_header}',
+            'AAAA=AAA',
+            'BBB=BBB',
+        )
+        assert f'multipart/magic; boundary={boundary_in_header}' in r
+        assert r.count(boundary_in_body) == 3
+
+    def test_multipart_chunked(self, httpbin):
+        r = http(
+            '--verbose',
+            '--multipart',
+            '--chunked',
+            HTTPBIN_WITH_CHUNKED_SUPPORT + '/post',
+            'AAA=AAA',
+        )
+        assert 'Transfer-Encoding: chunked' in r
+        assert 'multipart/form-data' in r
+        assert 'name="AAA"' in r  # in request
+        assert '"AAA": "AAA"', r  # in response
+
+    def test_multipart_preserve_order(self, httpbin):
+        r = http(
+            '--form',
+            '--offline',
+            httpbin + '/post',
+            'text_field=foo',
+            f'file_field@{FILE_PATH_ARG}',
+        )
+        assert r.index('text_field') < r.index('file_field')
+
+        r = http(
+            '--form',
+            '--offline',
+            httpbin + '/post',
+            f'file_field@{FILE_PATH_ARG}',
+            'text_field=foo',
+        )
+        assert r.index('text_field') > r.index('file_field')
+
+
+class TestRequestBodyFromFilePath:
+    """
+    `http URL @file'
+
+    """
+
+    def test_request_body_from_file_by_path(self, httpbin):
+        r = http(
+            '--verbose',
+            'POST', httpbin.url + '/post',
+            '@' + FILE_PATH_ARG,
+        )
+        assert HTTP_OK in r
+        assert r.count(FILE_CONTENT) == 2
+        assert '"Content-Type": "text/plain"' in r
+
+    def test_request_body_from_file_by_path_chunked(self, httpbin):
+        r = http(
+            '--verbose', '--chunked',
+            HTTPBIN_WITH_CHUNKED_SUPPORT + '/post',
+            '@' + FILE_PATH_ARG,
+        )
+        assert HTTP_OK in r
+        assert 'Transfer-Encoding: chunked' in r
+        assert '"Content-Type": "text/plain"' in r
+        assert r.count(FILE_CONTENT) == 2
+
+    def test_request_body_from_file_by_path_with_explicit_content_type(
+            self, httpbin):
+        r = http('--verbose',
+                 'POST', httpbin.url + '/post', '@' + FILE_PATH_ARG,
+                 'Content-Type:text/plain; charset=utf8')
+        assert HTTP_OK in r
+        assert FILE_CONTENT in r
+        assert 'Content-Type: text/plain; charset=utf8' in r
+
+    def test_request_body_from_file_by_path_no_field_name_allowed(
+            self, httpbin):
+        env = MockEnvironment(stdin_isatty=True)
+        r = http('POST', httpbin.url + '/post', 'field-name@' + FILE_PATH_ARG,
+                 env=env, tolerate_error_exit_status=True)
+        assert 'perhaps you meant --form?' in r.stderr
+
+    def test_request_body_from_file_by_path_no_data_items_allowed(
+            self, httpbin):
+        env = MockEnvironment(stdin_isatty=False)
+        r = http(
+            'POST',
+            httpbin.url + '/post',
+            '@' + FILE_PATH_ARG, 'foo=bar',
+            env=env,
+            tolerate_error_exit_status=True,
+        )
+        assert r.exit_status == ExitStatus.ERROR
+        assert 'cannot be mixed' in r.stderr

tests/test_windows.py

@@ -0,0 +1,31 @@
+import os
+import tempfile
+
+import pytest
+from httpie.context import Environment
+
+from utils import MockEnvironment, http
+from httpie.compat import is_windows
+
+
+@pytest.mark.skipif(not is_windows, reason='windows-only')
+class TestWindowsOnly:
+
+    @pytest.mark.skipif(True,
+                        reason='this test for some reason kills the process')
+    def test_windows_colorized_output(self, httpbin):
+        # Spits out the colorized output.
+        http(httpbin.url + '/get', env=Environment())
+
+
+class TestFakeWindows:
+    def test_output_file_pretty_not_allowed_on_windows(self, httpbin):
+        env = MockEnvironment(is_windows=True)
+        output_file = os.path.join(
+            tempfile.gettempdir(),
+            self.test_output_file_pretty_not_allowed_on_windows.__name__
+        )
+        r = http('--output', output_file,
+                 '--pretty=all', 'GET', httpbin.url + '/get',
+                 env=env, tolerate_error_exit_status=True)
+        assert 'Only terminal output can be colorized on Windows' in r.stderr

tests/utils.py

@@ -0,0 +1,297 @@
+# coding=utf-8
+"""Utilities for HTTPie test suite."""
+import sys
+import time
+import json
+import tempfile
+from io import BytesIO
+from pathlib import Path
+from typing import Optional, Union
+
+from httpie.status import ExitStatus
+from httpie.config import Config
+from httpie.context import Environment
+from httpie.core import main
+
+
+# pytest-httpbin currently does not support chunked requests:
+# <https://github.com/kevin1024/pytest-httpbin/issues/33>
+# <https://github.com/kevin1024/pytest-httpbin/issues/28>
+HTTPBIN_WITH_CHUNKED_SUPPORT = 'http://httpbin.org'
+
+
+TESTS_ROOT = Path(__file__).parent
+CRLF = '\r\n'
+COLOR = '\x1b['
+HTTP_OK = '200 OK'
+# noinspection GrazieInspection
+HTTP_OK_COLOR = (
+    'HTTP\x1b[39m\x1b[38;5;245m/\x1b[39m\x1b'
+    '[38;5;37m1.1\x1b[39m\x1b[38;5;245m \x1b[39m\x1b[38;5;37m200'
+    '\x1b[39m\x1b[38;5;245m \x1b[39m\x1b[38;5;136mOK'
+)
+
+
+def mk_config_dir() -> Path:
+    dirname = tempfile.mkdtemp(prefix='httpie_config_')
+    return Path(dirname)
+
+
+def add_auth(url, auth):
+    proto, rest = url.split('://', 1)
+    return proto + '://' + auth + '@' + rest
+
+
+class StdinBytesIO(BytesIO):
+    """To be used for `MockEnvironment.stdin`"""
+    len = 0  # See `prepare_request_body()`
+
+
+class MockEnvironment(Environment):
+    """Environment subclass with reasonable defaults for testing."""
+    colors = 0
+    stdin_isatty = True,
+    stdout_isatty = True
+    is_windows = False
+
+    def __init__(self, create_temp_config_dir=True, **kwargs):
+        if 'stdout' not in kwargs:
+            kwargs['stdout'] = tempfile.TemporaryFile(
+                mode='w+b',
+                prefix='httpie_stdout'
+            )
+        if 'stderr' not in kwargs:
+            kwargs['stderr'] = tempfile.TemporaryFile(
+                mode='w+t',
+                prefix='httpie_stderr'
+            )
+        super().__init__(**kwargs)
+        self._create_temp_config_dir = create_temp_config_dir
+        self._delete_config_dir = False
+        self._temp_dir = Path(tempfile.gettempdir())
+
+    @property
+    def config(self) -> Config:
+        if (self._create_temp_config_dir
+                and self._temp_dir not in self.config_dir.parents):
+            self.create_temp_config_dir()
+        return super().config
+
+    def create_temp_config_dir(self):
+        self.config_dir = mk_config_dir()
+        self._delete_config_dir = True
+
+    def cleanup(self):
+        self.stdout.close()
+        self.stderr.close()
+        if self._delete_config_dir:
+            assert self._temp_dir in self.config_dir.parents
+            from shutil import rmtree
+            rmtree(self.config_dir, ignore_errors=True)
+
+    def __del__(self):
+        # noinspection PyBroadException
+        try:
+            self.cleanup()
+        except Exception:
+            pass
+
+
+class BaseCLIResponse:
+    """
+    Represents the result of simulated `$ http' invocation via `http()`.
+
+    Holds and provides access to:
+
+        - stdout output: print(self)
+        - stderr output: print(self.stderr)
+        - devnull output: print(self.devnull)
+        - exit_status output: print(self.exit_status)
+
+    """
+    stderr: str = None
+    devnull: str = None
+    json: dict = None
+    exit_status: ExitStatus = None
+
+
+class BytesCLIResponse(bytes, BaseCLIResponse):
+    """
+    Used as a fallback when a StrCLIResponse cannot be used.
+
+    E.g. when the output contains binary data or when it is colorized.
+
+    `.json` will always be None.
+
+    """
+
+
+class StrCLIResponse(str, BaseCLIResponse):
+
+    @property
+    def json(self) -> Optional[dict]:
+        """
+        Return deserialized the request or response JSON body,
+        if one (and only one) included in the output and is parsable.
+
+        """
+        if not hasattr(self, '_json'):
+            self._json = None
+            # De-serialize JSON body if possible.
+            if COLOR in self:
+                # Colorized output cannot be parsed.
+                pass
+            elif self.strip().startswith('{'):
+                # Looks like JSON body.
+                self._json = json.loads(self)
+            elif self.count('Content-Type:') == 1:
+                # Looks like a HTTP message,
+                # try to extract JSON from its body.
+                try:
+                    j = self.strip()[self.strip().rindex('\r\n\r\n'):]
+                except ValueError:
+                    pass
+                else:
+                    try:
+                        # noinspection PyAttributeOutsideInit
+                        self._json = json.loads(j)
+                    except ValueError:
+                        pass
+        return self._json
+
+
+class ExitStatusError(Exception):
+    pass
+
+
+def http(
+    *args,
+    program_name='http',
+    tolerate_error_exit_status=False,
+    **kwargs,
+) -> Union[StrCLIResponse, BytesCLIResponse]:
+    # noinspection PyUnresolvedReferences
+    """
+    Run HTTPie and capture stderr/out and exit status.
+    Content writtent to devnull will be captured only if
+    env.devnull is set manually.
+
+    Invoke `httpie.core.main()` with `args` and `kwargs`,
+    and return a `CLIResponse` subclass instance.
+
+    The return value is either a `StrCLIResponse`, or `BytesCLIResponse`
+    if unable to decode the output. Devnull is string when possible,
+    bytes otherwise.
+
+    The response has the following attributes:
+
+        `stdout` is represented by the instance itself (print r)
+        `stderr`: text written to stderr
+        `devnull` text written to devnull.
+        `exit_status`: the exit status
+        `json`: decoded JSON (if possible) or `None`
+
+    Exceptions are propagated.
+
+    If you pass ``tolerate_error_exit_status=True``, then error exit statuses
+    won't result into an exception.
+
+    Example:
+
+    $ http --auth=user:password GET httpbin.org/basic-auth/user/password
+
+        >>> httpbin = getfixture('httpbin')
+        >>> r = http('-a', 'user:pw', httpbin.url + '/basic-auth/user/pw')
+        >>> type(r) == StrCLIResponse
+        True
+        >>> r.exit_status
+        <ExitStatus.SUCCESS: 0>
+        >>> r.stderr
+        ''
+        >>> 'HTTP/1.1 200 OK' in r
+        True
+        >>> r.json == {'authenticated': True, 'user': 'user'}
+        True
+
+    """
+    env = kwargs.get('env')
+    if not env:
+        env = kwargs['env'] = MockEnvironment()
+
+    stdout = env.stdout
+    stderr = env.stderr
+    devnull = env.devnull
+
+    args = list(args)
+    args_with_config_defaults = args + env.config.default_options
+    add_to_args = []
+    if '--debug' not in args_with_config_defaults:
+        if (not tolerate_error_exit_status
+                and '--traceback' not in args_with_config_defaults):
+            add_to_args.append('--traceback')
+        if not any('--timeout' in arg for arg in args_with_config_defaults):
+            add_to_args.append('--timeout=3')
+
+    complete_args = [program_name, *add_to_args, *args]
+    # print(' '.join(complete_args))
+
+    def dump_stderr():
+        stderr.seek(0)
+        sys.stderr.write(stderr.read())
+
+    try:
+        try:
+            exit_status = main(args=complete_args, **kwargs)
+            if '--download' in args:
+                # Let the progress reporter thread finish.
+                time.sleep(.5)
+        except SystemExit:
+            if tolerate_error_exit_status:
+                exit_status = ExitStatus.ERROR
+            else:
+                dump_stderr()
+                raise
+        except Exception:
+            stderr.seek(0)
+            sys.stderr.write(stderr.read())
+            raise
+        else:
+            if (not tolerate_error_exit_status
+                    and exit_status != ExitStatus.SUCCESS):
+                dump_stderr()
+                raise ExitStatusError(
+                    'httpie.core.main() unexpectedly returned'
+                    f' a non-zero exit status: {exit_status}'
+                )
+
+        stdout.seek(0)
+        stderr.seek(0)
+        devnull.seek(0)
+        output = stdout.read()
+        devnull_output = devnull.read()
+        try:
+            output = output.decode('utf8')
+        except UnicodeDecodeError:
+            r = BytesCLIResponse(output)
+        else:
+            r = StrCLIResponse(output)
+
+        try:
+            devnull_output = devnull_output.decode('utf8')
+        except Exception:
+            pass
+
+        r.devnull = devnull_output
+        r.stderr = stderr.read()
+        r.exit_status = exit_status
+
+        if r.exit_status != ExitStatus.SUCCESS:
+            sys.stderr.write(r.stderr)
+
+        return r
+
+    finally:
+        devnull.close()
+        stdout.close()
+        stderr.close()
+        env.cleanup()

tox.ini

@@ -1,19 +0,0 @@
-# Tox (http://tox.testrun.org/) is a tool for running tests
-# in multiple virtualenvs. This configuration file will run the
-# test suite on all supported python versions. To use it, "pip install tox"
-# and then run "tox" from this directory.
-
-[tox]
-envlist = py26, py27, py33, pypy
-
-[testenv]
-commands = {envpython} setup.py test
-
-[testenv:py26]
-deps = argparse
-
-[testenv:py30]
-deps = argparse
-
-[testenv:py31]
-deps = argparse