Posts about Python

everything

def old(foo, bar):
    """This is old's docstring."""
    print(foo, bar)
    return foo + bar

def new(prefix, foo, *args, **kwargs):
    return old(prefix + foo, *args, **kwargs)

>>> o = old('a', 'b')
a b
>>> n = new('!', 'a', 'b')
!a b
>>> print(o, n, sep=' - ')
ab - !ab
>>> help(old)
Help on function old in module __main__:

old(foo, bar)
    This is old's docstring.

>>> help(new)
Help on function new in module __main__:

new(prefix, foo, *args, **kwargs)

def decorator(f):
    @functools.wraps(f)
    def wrapper(*args, **kwargs):
        print("Inside wrapper")
        f(*args, **kwargs)
    return wrapper

@decorator
def square(n: float) -> float:
    """Square a number."""
    return n * n

>>> def foo(bar): pass
>>> foo.__wrapped__ = lambda x, y: None
>>> help(foo)
foo(x, y)

code(argcount, kwonlyargcount, nlocals, stacksize, flags, codestring,
    constants, names, varnames, filename, name, firstlineno,
    lnotab[, freevars[, cellvars]])

Create a code object.  Not for the faint of heart.

>>> def f(a, b=1, c=2, *, d=3): pass
>>> inspect.getfullargspec(f)
FullArgSpec(args=['a', 'b', 'c'], varargs=None, varkw=None, defaults=(1, 2), kwonlyargs=['d'], kwonlydefaults={'d': 3}, annotations={})

# old defined as before
@merge_args(old)
def new(prefix, foo, *args, **kwargs):
    return old(prefix + foo, *args, **kwargs)

new(prefix, foo, bar)
    This is old's docstring.

Linux:   $ python3 -m venv env
Windows: > py -m venv env

$ python3 -m virtualenv env
> py -m virtualenv env

$ env/bin/python -m pip install --upgrade pip setuptools wheel
> env\Scripts\python -m pip install --upgrade pip setuptools wheel

## *nix, activation ##
$ source /path/to/env/bin/activate
(env)$ pip install Django
(env)$ deactivate

## *nix, manual execution ##
$ /path/to/env/bin/pip install Django

## Windows, activation ##
> C:\path\to\env\Scripts\activate
(venv)> pip install Django
(venv)> deactivate

## Windows, manual execution ##
> C:\path\to\env\Scripts\pip install Django

## Windows, updating pip/setuptools/wheel ##
> C:\path\to\env\Scripts\python -m pip install -U pip setuptools wheel

$ oldenv/bin/pip freeze > requirements.txt
$ python3 -m venv newenv
$ newenv/bin/pip install -r requirements.txt
(You may rm -rf oldenv now if you desire)

$ ~/virtualenvs/foobar/bin/python ~/Downloads/repro.py

$ cd ~/git/foobar
$ pipenv run python ~/Downloads/repro.py

$ cd ~/git/foobar
$ pipenv shell
(foobar-Mwd1l2m9)$ cd ~/Downloads
(foobar-Mwd1l2m9)$ python repro.py
(foobar-Mwd1l2m9)$ exit  # (not deactivate!)

$ cd ~/Downloads
$ workon foobar
(foobar)$ python repro.py
(foobar)$ deactivate

MISSION 011               goo.gl/13Bia9             DIFFICULTY: ██████░░░░ [6╱10]
┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅

Finally some real work!

One of our field agents managed to infiltrate suspects hideout and steal a
pendrive possibly containing important information. However, the pendrive
actually requires one to authenticate themselves before accessing the stored
files.

We gave the pendrive to our laboratory and they managed to dump the firmware. We
looked at the deadlisting they sent and for our best knowledge it's some form of
Elvish. We can't read it.

Here is the firmware: goo.gl/axsAHt

And off you go. Bring us back the password.

Good luck!

---------------------------------------------------------------------------------

If you decode the answer, put it in the comments under this video! If you write
a blogpost / post your solution online, please add a link in the comments too!

P.S. I'll show/explain the solution on the stream in ~two weeks.
P.S.2. Bonus points for recreating the original high-level code.

co_argcount 1
co_consts (None, '4e5d4e92865a4e495a86494b5a5d49525261865f5758534d4a89', 'hex', 89, 255, 115, 50)
co_flags 67
co_name check_password
co_names ('decode', 'len', 'False', 'all', 'zip', 'ord')
co_nlocals 4
co_stacksize 6
co_varnames ('s', 'good', 'cs', 'cg')
              0 LOAD_CONST               1
              3 LOAD_ATTR                0
              6 LOAD_CONST               2
              9 CALL_FUNCTION            1
             12 STORE_FAST               1
             15 LOAD_GLOBAL              1
             18 LOAD_FAST                0
             21 CALL_FUNCTION            1
             24 LOAD_GLOBAL              1
             27 LOAD_FAST                1
             30 CALL_FUNCTION            1
             33 COMPARE_OP               3 (!=)
             36 POP_JUMP_IF_FALSE       43
             39 LOAD_GLOBAL              2
             42 RETURN_VALUE
        >>   43 LOAD_GLOBAL              3
             46 BUILD_LIST               0
             49 LOAD_GLOBAL              4
             52 LOAD_FAST                0
             55 LOAD_FAST                1
             58 CALL_FUNCTION            2
             61 GET_ITER
        >>   62 FOR_ITER                52 (to 117)
             65 UNPACK_SEQUENCE          2
             68 STORE_FAST               2
             71 STORE_FAST               3
             74 LOAD_GLOBAL              5
             77 LOAD_FAST                2
             80 CALL_FUNCTION            1
             83 LOAD_CONST               3
             86 BINARY_SUBTRACT
             87 LOAD_CONST               4
             90 BINARY_AND
             91 LOAD_CONST               5
             94 BINARY_XOR
             95 LOAD_CONST               6
             98 BINARY_XOR
             99 LOAD_GLOBAL              5
            102 LOAD_FAST                3
            105 CALL_FUNCTION            1
            108 COMPARE_OP               2 (==)
            111 LIST_APPEND              2
            114 JUMP_ABSOLUTE           62
        >>  117 CALL_FUNCTION            1
            120 RETURN_VALUE

#!/usr/bin/env python2
import dis
import sys

# Write code here
def check_password(s):
    pass

# Reverse engineering the code
cnames = ('co_argcount', 'co_consts', 'co_flags', 'co_name', 'co_names', 'co_nlocals', 'co_stacksize', 'co_varnames')
cvalues = (1, (None, '4e5d4e92865a4e495a86494b5a5d49525261865f5758534d4a89', 'hex', 89, 255, 115, 50), 67, 'check_password', ('decode', 'len', 'False', 'all', 'zip', 'ord'), 4, 6, ('s', 'good', 'cs', 'cg'))

for n, ov in zip(cnames, cvalues):
    v = getattr(check_password.__code__, n)
    if v == ov:
        sys.stderr.write('\033[1;32m')
    else:
        sys.stderr.write('\033[1;31m')
    sys.stderr.flush()

    sys.stdout.write(str(n) + " " + str(v) + "\n")
    sys.stdout.flush()

    sys.stderr.write('\033[0m')
    sys.stderr.flush()

dis.dis(check_password)

co_argcount 1            [OK]
co_consts (None,)        [1/7 match]
co_flags 67              [OK]
co_name check_password   [OK]
co_names ()              [0/6 match]
co_nlocals 1             [should be 4]
co_stacksize 1           [should be 6]
co_varnames ('s',)       [1/4 match]
  7           0 LOAD_CONST               0 (None)
              3 RETURN_VALUE

constants
 0     1                                                       2      3   4    5    6
(None, '4e5d4e92865a4e495a86494b5a5d49525261865f5758534d4a89', 'hex', 89, 255, 115, 50)

names (globals, attributes)
 0         1      2        3      4      5
('decode', 'len', 'False', 'all', 'zip', 'ord')

varnames (locals, _fast)
 0    1       2     3
('s', 'good', 'cs', 'cg')

 0 LOAD_CONST               1 ('4e5d4e92865a4e495a86494b5a5d49525261865f5758534d4a89')
 3 LOAD_ATTR                0 (decode)
 6 LOAD_CONST               2 ('hex')
 9 CALL_FUNCTION            1 # function takes 1 argument from stack
12 STORE_FAST               1 (good)

def check_password(s):
    good = '4e5d4e92865a4e495a86494b5a5d49525261865f5758534d4a89'.decode('hex')  # new

15 LOAD_GLOBAL              1
18 LOAD_FAST                0
21 CALL_FUNCTION            1
24 LOAD_GLOBAL              1
27 LOAD_FAST                1
30 CALL_FUNCTION            1
33 COMPARE_OP               3 (!=)
36 POP_JUMP_IF_FALSE       43
39 LOAD_GLOBAL              2
42 RETURN_VALUE

def check_password(s):
    good = '4e5d4e92865a4e495a86494b5a5d49525261865f5758534d4a89'.decode('hex')
    if len(s) != len(good):  # new
        return False         # new

>>   43 LOAD_GLOBAL              3 (all)
     46 BUILD_LIST               0
     49 LOAD_GLOBAL              4 (zip)
     52 LOAD_FAST                0 (s)
     55 LOAD_FAST                1 (good)
     58 CALL_FUNCTION            2           # zip(s, good)
     61 GET_ITER                             # Start iterating: iter()
>>   62 FOR_ITER                52 (to 117)  # for loop iteration start (if iterator exhausted, jump +52 bytes to position 117)
     65 UNPACK_SEQUENCE          2           # unpack a sequence (a, b = sequence)
     68 STORE_FAST               2 (cs)      # cs = item from s
     71 STORE_FAST               3 (cg)      # cg = item from good
     74 LOAD_GLOBAL              5 (ord)
     77 LOAD_FAST                2 (cs)
     80 CALL_FUNCTION            1           # put ord(cs) on stack
     83 LOAD_CONST               3 (89)
     86 BINARY_SUBTRACT                      # - 89   [subtract 89 from topmost value]
     87 LOAD_CONST               4 (255)
     90 BINARY_AND                           # & 255  [bitwise AND with topmost value]
     91 LOAD_CONST               5 (115)
     94 BINARY_XOR                           # ^ 115  [bitwise XOR with topmost value]
     95 LOAD_CONST               6 (50)
     98 BINARY_XOR                           # ^ 50   [bitwise XOR with topmost value]
     99 LOAD_GLOBAL              5 (ord)
    102 LOAD_FAST                3 (cg)
    105 CALL_FUNCTION            1           # put ord(cs) on stack
    108 COMPARE_OP               2 (==)      # compare the two values on stack
    111 LIST_APPEND              2           # append topmost value to the list in topmost-1; pop topmost (append to list created in comprehension)
    114 JUMP_ABSOLUTE           62           # jump back to start of loop
>>  117 CALL_FUNCTION            1           # after loop: call all([list comprehension result])
    120 RETURN_VALUE                         # return value returned by all()

co_consts (None, '4e5d4e92865a4e495a86494b5a5d49525261865f5758534d4a89', 'hex',  at 0x104a86c30, file "mission11-genexpr.py", line 11>)

46 LOAD_CONST               3 ( at 0x104a86c30, file "mission11-genexpr.py", line 11>)

pass_values = {}
for i in range(256):
    result = i - 89 & 255 ^ 115 ^ 50
    pass_values[result] = i

good = '4e5d4e92865a4e495a86494b5a5d49525261865f5758534d4a89'.decode('hex')
password = ''
for c in good:
    password += chr(pass_values[ord(c)])

print(password)
print(check_password(password))

apt install python3 python3-venv uwsgi uwsgi-emperor uwsgi-plugin-python3 nginx-full git

dnf install python3 uwsgi uwsgi-plugin-python3 uwsgi-logger-file nginx git

yum install epel-release
yum install python36 uwsgi uwsgi-plugin-python36 uwsgi-logger-file nginx git wget

dnf install epel-release
dnf install python36 uwsgi uwsgi-plugin-python3 uwsgi-logger-file nginx git wget

pacman -S python uwsgi uwsgi-plugin-python nginx git

mkdir /srv/myapp
python3 -m venv --prompt myapp /srv/myapp/venv

cd /srv/myapp
git clone https://github.com/Kwpolska/flask-demo-app appdata
venv/bin/pip install -r appdata/requirements.txt

chown -R www-data:www-data /srv/myapp

chown -R uwsgi:nginx /srv/myapp

chown -R http:http /srv/myapp

systemctl enable nginx emperor.uwsgi
systemctl start nginx emperor.uwsgi

systemctl enable nginx uwsgi
systemctl start nginx uwsgi

setenforce 0
chcon -R system_u:system_r:httpd_t:s0 /srv/myapp/appdata/static
setenforce 1

semodule -i nginx-uwsgi.pp

systemctl stop uwsgi-emperor
systemctl disable uwsgi-emperor

ExecStart=/usr/bin/uwsgi --ini /etc/uwsgi-emperor/emperor.ini

systemctl daemon-reload
systemctl enable nginx emperor.uwsgi
systemctl reload nginx
systemctl start emperor.uwsgi

curl -v http://localhost/
curl -I http://localhost/favicon.ico
curl -I http://localhost/static/hello.png

firewall-cmd --add-service http
firewall-cmd --add-service https

languages = models.ManyToManyField(Language)

publish_email = forms.BooleanField("Publish e-mail", required=False)
TypeError: "BooleanField() got multiple values for argument 'required'"

	`FROM python:3.14-alpine AS build`
	`WORKDIR /app`
	`RUN apk add build-base libpq libpq-dev`
	`RUN python -m venv /venv && /venv/bin/python -m pip install --no-cache-dir -U pip`
	`COPY requirements.txt /app`
	`RUN /venv/bin/pip install --no-cache-dir -r requirements.txt`
	`COPY nikolausers /app/nikolausers`
	`COPY sites /app/sites`
	`COPY templates /app/templates`
	`COPY manage.py docker/docker-entrypoint.sh /app/`
	`RUN chmod +x /app/docker-entrypoint.sh`

	`FROM python:3.14-alpine`
	`WORKDIR /app`
	`RUN apk add libpq`
	`COPY --from=build /venv /venv`
	`COPY --from=build /app /app`
	`ENTRYPOINT ["/app/docker-entrypoint.sh"]`

	`#!/bin/sh`
	`statefile=/tmp/migrated`
	`if [ ! -f "$statefile" ]; then`
	`/venv/bin/python manage.py collectstatic --noinput`
	`/venv/bin/python manage.py migrate --noinput`
	`touch "$statefile"`
	`fi`
	`exec /venv/bin/python -m gunicorn --bind 0.0.0.0:6868 nikolausers.asgi:application -k uvicorn_worker.UvicornWorker -w 3`

	`services:`
	`nikolausers:`
	`restart: unless-stopped`
	`image: nikolausers:latest`
	`ports:`
	`- 127.0.0.1:6868:6868`
	`user: "33:33" # www-data on Debian`
	`environment:`
	`#SECRET_KEY: ""`
	`#DB_NAME: ""`
	`#DB_USER: ""`
	`#DB_PASSWORD: ""`
	`#DB_HOST: ""`
	`#EMAIL_HOST: ""`
	`volumes:`
	`- ./static:/app/static`

	`server {`
	`# skip standard host config...`

	`location / {`
	`proxy_pass http://127.0.0.1:6868/;`
	`include proxy_params;`
	`}`

	`location /static {`
	`alias /srv/users.getnikola.com/static;`
	`}`
	`}`

Tool	Maintainer	Use-case	# of supported features	# of partially supported features	# of unsupported features
setuptools	PyPA	Making things installable	4	2 (pyproject.toml partially in beta, installing—only setuptools-based sdists)	3
pip	PyPA	Installing packages	2	1 (Locking dependencies only manually)	6
venv	PyPA	Creating virtual environments	1 (Creating environments)	0	8
wheel	PyPA	Building wheels in setuptools	0	1 (Building wheels in setuptools)	8
Twine	PyPA	Uploading to PyPI	1 (Uploading to PyPI)	0	8
pip-tools	Jazzband	Managing requirements files	2 (Locking dependencies, installing packages)	0	7
virtualenvwrapper	Doug Hellmann	Managing virtual environments	1 (Managing environments)	0	8
pipx	PyPA	Installing Python command-line tools	2 (Installing packages, editable installs)	1 (Managing environments)	6
conda	Anaconda, Inc.	Managing environments and dependencies	3 (Managing environments, installing things)	4 (Manual locking, packaging requires conda-build)	2 (pyproject.toml and PyPI)
Pipenv	PyPA	Managing dependencies for apps	3 (Managing environments, installing and locking)	1 (Developing apps)	5
Poetry	Sébastien Eustace et al.	Packaging and managing dependencies	7	2 (pyproject.toml, C extensions)	0
Flit	PyPA	Packaging pure-Python projects	5	1 (Installing only flit packages)	3
Hatch	PyPA	Packaging and managing dependencies	7	0	2 (C extensions, locking dependencies)
PDM	Frost Ming	Packaging and managing dependencies	8	0	1 (C extensions)

	`export WORKON_HOME=~/virtualenvs`

	`function workon {`
	`source "$WORKON_HOME/$1/bin/activate"`
	`}`

	`$WORKON_HOME = "$home\virtualenvs"`
	`& "$WORKON_HOME\$($args[0])\Scripts\activate.ps1"`

Task	Action	Measurement method	Environment	Cache	Times in seconds
Task	Action	Measurement method	Environment	Cache	Attempt 1	Attempt 2	Attempt 3	Average
1	virtualenv	`time`	Remote	(not applicable)	3.911	4.052	3.914	3.959
2	pip install Nikola	`time`	Remote	Removed	11.562	11.943	11.773	11.759
3	pip install Nikola	`time`	Remote	Kept	7.404	7.681	7.569	7.551
4	pipenv install Nikola	`time`	Remote	Removed	67.536	62.973	71.305	67.271
	├─ locking/installing from lockfile	stopwatch			42.6	40.5	39.6	40.9
	└─ Pipfile.lock install	pipenv			14	14	13	13.667
5	adding Django to an environment	`time`	Remote	Kept (only Nikola in cache)	39.576	—	—	39.576
	├─ locking/installing from lockfile	stopwatch			32	—	—	32
	└─ Pipfile.lock install	pipenv			14	—	—	14
6	adding Django to another environment	`time`	Remote	Kept (both in cache)	37.978	—	—	37.978
	├─ locking/installing from lockfile	stopwatch			30.2	—	—	30.2
	└─ Pipfile.lock install	pipenv			14	—	—	14
7	pipenv install Django	`time`	Remote	Removed	20.612	20.666	20.665	20.648
	├─ locking/installing from lockfile	stopwatch			6.6	6.4	6	6.333
	└─ Pipfile.lock install	pipenv			1	1	1	1
8	pipenv install Django (new env)	`time`	Remote	Kept	17.615	—	—	17.615
	├─ locking/installing from lockfile	stopwatch			3.5	—	—	3.5
	└─ Pipfile.lock install	pipenv			1	—	—	1
9	pipenv install Nikola	`time`	Remote	Partial	61.507	—	—	61.507
	├─ locking/installing from lockfile	stopwatch			38.40	—	—	38.40
	└─ Pipfile.lock install	pipenv			14	—	—	14
10	pipenv install Django	`time`	Local	Removed	73.933	—	—	73.933
	├─ locking/installing from lockfile	stopwatch			46	—	—	46
	└─ Pipfile.lock install	pipenv			0	—	—	0
11	virtualenv	`time`	Local	(not applicable)	5.864	—	—	5.864
12	pip install Nikola (cached)	`time`	Local	Kept	10.951	—	—	10.951
13	pipenv install Nikola	`time`	Local	Partial, after interruption	607.647	(10m 7s)		607.647
	├─ locking/installing from lockfile	stopwatch			590.85	(9m 50s)		590.85
	└─ Pipfile.lock install	pipenv			6			6
14	pipenv install	`time`	Local	Kept	31.399	(L/I: 10.51 s)		31.399

Date/Time (UTC)	Event
2017-01-31 22:01	v3.2.14 released. `pipenv --three` creates `./.venv` (eg. `~/git/foo/.venv`). Last version with the original behavior of pipenv.
2017-02-01 05:36	v3.3.0 released. `pipenv --three` creates `~/.local/share/virtualenvs/foo` (to be precise, `$WORKON_HOME/foo`).
2017-02-01 06:10	Issue #178 is reported regarding the behavior change.
2017-02-01 06:18	Kenneth Reitz responds: “no plans for making it configurable.” and closes the issue.
2017-02-02 03:05	Kenneth Reitz responds: “added `PIPENV_VENV_IN_PROJECT` mode for classic operation. Not released yet.”
2017-02-02 04:29	v3.3.3 released. The default is still uses a “remote” location, but `.venv` can now be used.
2017-03-02 13:48	v3.5.0 released. The new default path is `$WORKON_HOME/foo-HASH`, eg. `~/.local/share/virtualenvs/foo-7pl2iuUI`.

	`def check_password(s):`
	`good = '4e5d4e92865a4e495a86494b5a5d49525261865f5758534d4a89'.decode('hex')`
	`if len(s) != len(good):`
	`return False`

	`return all([ord(cs) - 89 & 255 ^ 115 ^ 50 == ord(cg) for cs, cg in zip(s, good)])`

	`#!/usr/bin/env python2`

	`import sys`
	`sys.path.append("mission11.bmp")`

	`import mission11`
	`print "Result:", mission11.check_password('huh, that actually worked!')`

	`[uwsgi]`
	`socket = /srv/myapp/uwsgi.sock`
	`chmod-socket = 775`
	`chdir = /srv/myapp/appdata`
	`master = true`
	`binary-path = /srv/myapp/venv/bin/uwsgi`
	`virtualenv = /srv/myapp/venv`
	`module = flaskapp:app`
	`uid = www-data`
	`gid = www-data`
	`processes = 1`
	`threads = 1`
	`plugins = python3,logfile`
	`logger = file:/srv/myapp/uwsgi.log`

Framework	Flask, Bottle	Django	Pyramid
Package	module where `app` is defined	`project.wsgi` (`project` is the package with `settings.py`)	module where `app` is defined
Callable	Flask: `app` instance Bottle: `app = bottle.default_app()`	`application`	`app = config.make_wsgi_app()`
Module	`package:app`	`project.wsgi:application`	`package:app`
Caveats	Make sure `app` is not in an `if __name__ == '__main__':` block	Add environment variable for settings: `env = DJANGO_SETTINGS_MODULE=project.settings`	Make sure `app` is not in an `if __name__ == '__main__':` block (the demo quickstart does that!)

	`server {`
	`# for a public HTTP server:`
	`listen 80;`
	`# for a public HTTPS server:`
	`# listen 443 ssl;`
	`server_name localhost myapp.local;`

	`location / {`
	`include uwsgi_params;`
	`uwsgi_pass unix:/srv/myapp/uwsgi.sock;`
	`}`

	`location /static {`
	`alias /srv/myapp/appdata/static;`
	`}`

	`location /favicon.ico {`
	`alias /srv/myapp/appdata/static/favicon.ico;`
	`}`
	`}`

Posts about Python

Deploying Python Web Applications with Docker

Why Docker?

Should everything be in Docker?

What should be in Docker?

Linux and Python (base image)

Virtual environments and dependency management

WSGI server

Scripts and configuration files

Dockerfile

docker-entrypoint.sh

docker-compose.yml

nginx

Conclusion

Python Packaging, One Year Later: A Look Back at 2023 in Python Packaging

The tools

The standards

Learning curves and the deception of “simple”

The future…

…is looking pretty bleak

Conclusion

Footnotes

How to improve Python packaging, or why fourteen tools are at least twelve too many

The plethora of tools

The classic stack

…and a few extensions

The scientific stack and conda

The new tools

Tooling proliferation and the Python Package Authority

Python Hackery: merging signatures of two Python functions

Starting point

The existing infrastructure: functools.wraps

Defining a function programmatically

Code objects

Everything you need to know about function arguments

Final results

Python Virtual Environments in Five Minutes

Install

Create

Where to store virtual environments?

Use

Moving/renaming/copying environments?

Frequently Asked Questions

I’m using virtualenv. Do I need to install it for each Python I want to use it with?

I’m the only user on my system. Do I still need virtual environments?

I’m using Docker. Do I still need virtual environments?

What about Pipenv?

Footnotes

Pipenv: promises a lot, delivers very little

A 2020 update (updated)

“Officially recommended tool”, or how we got here

What pipenv does

Application dependencies

Running scripts (badly)

Finishing it all up

What pipenv doesn’t do

Setup.py, source distributions, and wheels

Working outside of the project root

Nikola

The part where I try to measure times

Alternative tools

Pip-tools: locking and hashing, and that is all

Poetry: better, but still not convincing

Pip is here to stay!

The break-neck pace of Pipenv

Conclusion

Gynvael’s Mission 11 (en): Python bytecode reverse-engineering

Reverse-engineering Python bytecode: re-creating the function by hand

Solving the real puzzle

What was that Paint thing about?

Resources

Setting up a Python development environment

Glossary and questions

Python versions: 2 vs 3

Can I run multiple Pythons on the same machine?

Implementations

Distributions

Can I make .exe files from Python programs?

Where to learn Python? Where to get help?

Installing Python