rwt 4.4.2

Interactive Interpreter

RWT also offers a painless way to run a Python interactive interpreter in the context of certain dependencies:

$ /clean-install/python -m rwt -q boto
>>> import boto
>>>

Command Runner

Note that everything after the – is passed to the python invocation, so it’s possible to have a one-liner that runs under a dependency context:

$ python -m rwt -q requests -- -c "import requests; print(requests.get('https://pypi-hypernode.com/project/rwt').status_code)"
200

Script Runner

Let’s say you have a script that has a one-off purpose. It’s either not part of a library, where dependencies are normally declared, or it is normally executed outside the context of that library. Still, that script probably has dependencies, say on requests. Here’s how you can use rwt to declare the dependencies and launch the script in a context where those dependencies have been resolved.

First, add a __requires__ directive at the head of the script:

#!/usr/bin/env python

__requires__ = ['requests']

import requests

req = requests.get('https://pypi-hypernode.com/project/rwt')
print(req.status_code)

Then, simply invoke that script with rwt:

$ python -m rwt -q -- myscript.py
200

The format for requirements must follow PEP 508.

Note that URLs specifiers are not supported by pip, but rwt supports a global __dependency_links__ attribute which can be used, for example, to install requirement from a project VCS URL:

#!/usr/bin/env python

__requires__ = ['foo==0.42']
__dependency_links__ = ['git+ssh://git@example.com/repo.git#egg=foo-0.42']

[...]

rwt also recognizes a global __index_url__ attribute. If present, this value will supply --index-url to pip with the attribute value, allowing a script to specify a custom package index:

#!/usr/bin/env python

__requires__ = ['my_private_package']
__index_url__ = 'https://my.private.index/'

import my_private_package
...

Replacing setup_requires

Following the script example, you can make your setup.py file compatible with rwt by declaring your depenedencies in the __requires__ directive:

#!/usr/bin/env python

__requires__ = ['setuptools', 'setuptools_scm']

import setuptools

setuptools.setup(
    ...
    setup_requires=__requires__,
)

When invoked with rwt, the dependencies will be assured before the script is run, or if run with setuptools, the dependencies will be loaded using the older technique, so the script is backward compatible.

Replacing tests_require

Although this example is included for completeness, because the technique is somewhat clumsy, the author currently recommends using tox for running tests except in extremely lean environments.

You can also replace tests_require. Consider a package that runs tests using setup.py test and relies on the tests_require directive to resolve dependencies needed during testing. Simply declare your dependencies in a separate file, e.g. “tests/requirements.txt”:

cat > tests/requiremenst.txt
pytest

For compatibility, expose those same requirements as tests_require in setup.py:

with io.open('tests/requirements.txt') as tr:
    tests_require = [
            line.rstrip()
            for line in tr
            if re.match('\w+', line)
    ]

setuptools.setup(
    ...
    tests_require=tests_require,
)

Then invoke tests with rwt:

$ python -m rwt -r tests/requirements.txt -- setup.py test

While still supporting the old technique:

$ python setup.py test

Supplying parameters to Pip

If you’ve been using rwt, you may have defined some requirements in the __requires__ of a script, but now you wish to install those to a more permanent environment. rwt provides a routine to facilitate this case:

$ python -m rwt.read-deps script.py my_dependency

If you’re on Unix, you may pipe this result directly to pip:

$ pip install $(python -m rwt.read-deps script.py)

And since pipenv uses the same syntax, the same technique works for pipenv:

$ pipenv install $(python -m rwt.read-deps script.py)