Python 3.13.7

https://docs.python.org/3.13/
Admin
Official documentation for Python 3.13.7, covering its features, syntax, standard library, setup,...
Tokens:1,662,915
Snippets:22,422
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Display expression example setup

Source: https://docs.python.org/3.13/library/pdb.html

Initial code setup to demonstrate the display command behavior with mutable objects.

```python
lst = []
breakpoint()
pass
lst.append(1)
print(lst)
```

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

### Setup Virtual Environment and Install Package

Source: https://docs.python.org/3.13/library/importlib.metadata.html

Commands to create a virtual environment and install a package for metadata inspection.

```bash
$ python -m venv example
$ source example/bin/activate
(example) $ python -m pip install wheel
```

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

### Demonstrate Process lifecycle methods

Source: https://docs.python.org/3.13/library/multiprocessing.html

Example showing the creation, starting, and termination of a process using the spawn context.

```python
>>> import multiprocessing, time, signal
>>> mp_context = multiprocessing.get_context('spawn')
>>> p = mp_context.Process(target=time.sleep, args=(1000,))
>>> print(p, p.is_alive())
<...Process ... initial> False
>>> p.start()
>>> print(p, p.is_alive())
<...Process ... started> True
>>> p.terminate()
>>> time.sleep(0.1)
>>> print(p, p.is_alive())
<...Process ... stopped exitcode=-SIGTERM> False
>>> p.exitcode == -signal.SIGTERM
True
```

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

### Example PATH environment variable configuration

Source: https://docs.python.org/3.13/using/windows.html

Shows a sample PATH string containing system directories and a Python installation path.

```text
C:\WINDOWS\system32;C:\WINDOWS;C:\Program Files\Python 3.9
```

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

### Configure setup.py for Multiple Extensions

Source: https://docs.python.org/3.13/extending/newtypes_tutorial.html

Update the setup script to include multiple extension modules for installation.

```python
from setuptools import Extension, setup
setup(ext_modules=[
    Extension("custom", ["custom.c"]),
    Extension("custom2", ["custom2.c"]),
])
```

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

### Example config.site file

Source: https://docs.python.org/3.13/using/configure.html

An example of a configuration site file used to provide overrides for the build process.

```text
ac_cv_func_setpgrp_void=yes
```

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

### start(initializer, initargs)

Source: https://docs.python.org/3.13/library/multiprocessing.html

Starts the manager's server process.

```APIDOC
## start(initializer=None, initargs=())

### Description
Starts a subprocess to run the manager server. If an initializer is provided, it is called when the subprocess starts.
```

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

### Configure installation via unattend.xml

Source: https://docs.python.org/3.13/using/windows.html

Place this file alongside the installer executable to define installation options using XML attributes or element text.

```xml
<Options>
    <Option Name="InstallAllUsers" Value="no" />
    <Option Name="Include_launcher" Value="0" />
    <Option Name="Include_test" Value="no" />
    <Option Name="SimpleInstall" Value="yes" />
    <Option Name="SimpleInstallDescription">Just for me, no test suite</Option>
</Options>
```

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

### CLI logging output examples

Source: https://docs.python.org/3.13/howto/logging-cookbook.html

Example console outputs for different logging levels.

```text
$ python app.py start foo
INFO start Started the 'foo' service.

$ python app.py stop foo bar
INFO stop Stopped the 'foo' and 'bar' services.

$ python app.py restart foo bar baz
INFO restart Restarted the 'foo', 'bar' and 'baz' services.
```

```text
$ python app.py --log-level DEBUG start foo
DEBUG start About to start foo
INFO start Started the 'foo' service.

$ python app.py --log-level DEBUG stop foo bar
DEBUG stop About to stop 'foo' and 'bar'
INFO stop Stopped the 'foo' and 'bar' services.

$ python app.py --log-level DEBUG restart foo bar baz
DEBUG restart About to restart 'foo', 'bar' and 'baz'
INFO restart Restarted the 'foo', 'bar' and 'baz' services.
```

```text
$ python app.py --log-level WARNING start foo
$ python app.py --log-level WARNING stop foo bar
$ python app.py --log-level WARNING restart foo bar baz
```

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

### Display Windows command prompt examples

Source: https://docs.python.org/3.13/faq/windows.html

Examples of standard Windows command prompt paths.

```text
C:\>
```

```text
D:\YourName\Projects\Python>
```

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

### Example .pth file contents

Source: https://docs.python.org/3.13/library/site.html

Example content for path configuration files used to extend sys.path.

```text
# foo package configuration

foo
bar
bletch
```

```text
# bar package configuration

bar
```

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

### Example command-line input for custom actions

Source: https://docs.python.org/3.13/library/optparse.html

Example of how a custom 'extend' action would process comma-delimited input.

```text
--names=foo,bar --names blah --names ding,dong
```

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

### Installing Packages from a Requirements File

Source: https://docs.python.org/3.13/tutorial/venv.html

Installs all packages listed in a requirements.txt file into the current virtual environment.

```bash
(tutorial-env) $ python -m pip install -r requirements.txt
Collecting novas==3.1.1.3 (from -r requirements.txt (line 1))
  ...
Collecting numpy==1.9.2 (from -r requirements.txt (line 2))
  ...
Collecting requests==2.7.0 (from -r requirements.txt (line 3))
  ...
Installing collected packages: novas, numpy, requests
  Running setup.py install for novas
Successfully installed novas-3.1.1.3 numpy-1.9.2 requests-2.7.0
```

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

### Start and join multiple threads

Source: https://docs.python.org/3.13/library/threading.html

Demonstrates creating, starting, and waiting for a list of threads to complete execution.

```python
threads = []
for link in links:
    # Using `args` to pass positional arguments and `kwargs` for keyword arguments
    t = threading.Thread(target=crawl, args=(link,), kwargs={"delay": 2})
    threads.append(t)

# Start each thread
for t in threads:
    t.start()

# Wait for all threads to finish
for t in threads:
    t.join()
```

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

### Manually start and stop a patcher

Source: https://docs.python.org/3.13/library/unittest.mock.html

Use start() and stop() to manually control the lifecycle of a patcher, which is useful for setup and teardown methods.

```python
>>> patcher = patch('package.module.ClassName')
>>> from package import module
>>> original = module.ClassName
>>> new_mock = patcher.start()
>>> assert module.ClassName is not original
>>> assert module.ClassName is new_mock
>>> patcher.stop()
>>> assert module.ClassName is original
>>> assert module.ClassName is not new_mock
```

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

### Generate sequences with range()

Source: https://docs.python.org/3.13/tutorial/controlflow.html

Examples of using start, stop, and step arguments in range().

```python
>>> list(range(5, 10))
[5, 6, 7, 8, 9]

>>> list(range(0, 10, 3))
[0, 3, 6, 9]

>>> list(range(-10, -100, -30))
[-10, -40, -70]
```

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

### Get distribution version

Source: https://docs.python.org/3.13/library/importlib.metadata.html

Retrieves the version number of an installed distribution package as a string.

```python
>>> version('wheel')
'0.32.3'
```

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

### turtle.setup()

Source: https://docs.python.org/3.13/library/turtle.html

Sets the size and position of the main window.

```APIDOC
## turtle.setup(width, height, startx, starty)

### Description
Set the size and position of the main window.

### Parameters
- **width** (int/float) - Optional - If an integer, a size in pixels, if a float, a fraction of the screen.
- **height** (int/float) - Optional - If an integer, the height in pixels, if a float, a fraction of the screen.
- **startx** (int/None) - Optional - If positive, starting position in pixels from the left edge, if negative from the right edge, if None, center horizontally.
- **starty** (int/None) - Optional - If positive, starting position in pixels from the top edge, if negative from the bottom edge, if None, center vertically.
```

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

### patcher.start() and patcher.stop()

Source: https://docs.python.org/3.13/library/unittest.mock.html

Methods to manually start and stop a patcher, useful for setup and teardown logic.

```APIDOC
## patcher.start()

### Description
Activates the patcher, replacing the target object with a mock. Returns the created mock object.

## patcher.stop()

### Description
Deactivates the patcher, restoring the original object.
```

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

### Configure Windows STARTUPINFO

Source: https://docs.python.org/3.13/library/subprocess.html

Example of initializing STARTUPINFO and setting dwFlags to use standard handles and window visibility settings.

```python
si = subprocess.STARTUPINFO()
si.dwFlags = subprocess.STARTF_USESTDHANDLES | subprocess.STARTF_USESHOWWINDOW
```

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

### Set First Weekday

Source: https://docs.python.org/3.13/library/calendar.html

Example of setting the starting day of the week to Sunday using the calendar module.

```python
import calendar
calendar.setfirstweekday(calendar.SUNDAY)
```

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

### Managing patches with start and stop

Source: https://docs.python.org/3.13/library/unittest.mock-examples.html

Control patch lifecycle manually within setUp and tearDown methods.

```python
>>> class MyTest(unittest.TestCase):
...     def setUp(self):
...         self.patcher = patch('mymodule.foo')
...         self.mock_foo = self.patcher.start()
...
...     def test_foo(self):
...         self.assertIs(mymodule.foo, self.mock_foo)
...
...     def tearDown(self):
...         self.patcher.stop()
...
>>> MyTest('test_foo').run()
```

```python
>>> class MyTest(unittest.TestCase):
...     def setUp(self):
...         patcher = patch('mymodule.foo')
...         self.addCleanup(patcher.stop)
...         self.mock_foo = patcher.start()
...
...     def test_foo(self):
...         self.assertIs(mymodule.foo, self.mock_foo)
...
>>> MyTest('test_foo').run()
```

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

### Create a setup.py for Python packages

Source: https://docs.python.org/3.13/whatsnew/2.0.html

Use this script when the software consists of one or more packages.

```python
from distutils.core import setup
setup (name = "foo", version = "1.0",
       packages = ["package", "package.subpackage"])
```

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

### Initialize Application and Logging

Source: https://docs.python.org/3.13/howto/logging-cookbook.html

Main entry point for setting up the application thread and logging configuration.

```python
def main():
    QtCore.QThread.currentThread().setObjectName('MainThread')
    logging.getLogger().setLevel(logging.DEBUG)
    app = QtWidgets.QApplication(sys.argv)
    example = Window(app)
    example.show()
    if hasattr(app, 'exec'):
        rc = app.exec()
    else:
        rc = app.exec_()
    sys.exit(rc)

if __name__=='__main__':
    main()
```

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

### Create a setup.py for C extensions

Source: https://docs.python.org/3.13/whatsnew/2.0.html

Use the Extension class to define C modules, including macros, include directories, and source files.

```python
from distutils.core import setup, Extension

expat_extension = Extension('xml.parsers.pyexpat',
     define_macros = [('XML_NS', None)],
     include_dirs = [ 'extensions/expat/xmltok',
                      'extensions/expat/xmlparse' ],
     sources = [ 'extensions/pyexpat.c',
                 'extensions/expat/xmltok/xmltok.c',
                 'extensions/expat/xmltok/xmlrole.c', ]
       )
setup (name = "PyXML", version = "0.5.4",
       ext_modules =[ expat_extension ] )
```

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

### Apply PEP 8 Style Formatting

Source: https://docs.python.org/3.13/tutorial/controlflow.html

Example of proper spacing around operators and after commas as recommended by the PEP 8 style guide.

```python
a = f(1, 2) + g(3, 4)
```

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

### os.startfile(path, operation=None, arguments=None, cwd=None, show_cmd=None)

Source: https://docs.python.org/3.13/library/os.html

Starts a file with its associated application on Windows.

```APIDOC
## os.startfile(path, operation=None, arguments=None, cwd=None, show_cmd=None)

### Description
Start a file with its associated application. When operation is not specified, this acts like double-clicking the file in Windows Explorer.

### Parameters
- **path** (string) - Required - The path to the file to be opened.
- **operation** (string) - Optional - A command verb such as 'open', 'print', 'edit', 'explore', or 'find'.
- **arguments** (string) - Optional - Arguments to be passed as a single string when launching an application.
- **cwd** (string) - Optional - The working directory for the process.
- **show_cmd** (int) - Optional - Window style integer supported by the Win32 ShellExecute() function.
```

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

### tracemalloc.start(nframe=1)

Source: https://docs.python.org/3.13/library/tracemalloc.html

Starts tracing Python memory allocations by installing hooks on memory allocators. The nframe parameter limits the number of frames stored in tracebacks.

```APIDOC
## tracemalloc.start(nframe: int = 1)

### Description
Starts tracing Python memory allocations. Collected tracebacks are limited to nframe frames.

### Parameters
- **nframe** (int) - Optional - The maximum number of frames to store in the traceback. Must be >= 1.
```

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

### Create a simplified personal installation shortcut

Source: https://docs.python.org/3.13/using/windows.html

This command displays a simplified UI for a per-user installation, disabling customization and the test suite.

```bash
python-3.9.0.exe InstallAllUsers=0 Include_launcher=0 Include_test=0
    SimpleInstall=1 SimpleInstallDescription="Just for me, no test suite."
```

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

### TypeVar Tuple Unpacking

Source: https://docs.python.org/3.13/whatsnew/changelog.html

Examples of splitting unpacked arbitrary-length tuples over TypeVar and TypeVarTuple parameters.

```python
A[T, *Ts][*tuple[int, ...]] -> A[int, *tuple[int, ...]]
```

```python
A[*Ts, T][*tuple[int, ...]] -> A[*tuple[int, ...], int]
```

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

### CSV File Content Example

Source: https://docs.python.org/3.13/library/csv.html

Example content for the names.csv file used in the DictReader and DictWriter examples.

```text
first_name,last_name
Eric,Idle
John,Cleese
```

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

### Initialize Python with modified configuration

Source: https://docs.python.org/3.13/c-api/init_config.html

Shows how to read the default configuration, override specific parameters like sys.path and the executable, and initialize the interpreter.

```c
PyStatus init_python(const char *program_name)
{
    PyStatus status;

    PyConfig config;
    PyConfig_InitPythonConfig(&config);

    /* Set the program name before reading the configuration
       (decode byte string from the locale encoding).

       Implicitly preinitialize Python. */
    status = PyConfig_SetBytesString(&config, &config.program_name,
                                     program_name);
    if (PyStatus_Exception(status)) {
        goto done;
    }

    /* Read all configuration at once */
    status = PyConfig_Read(&config);
    if (PyStatus_Exception(status)) {
        goto done;
    }

    /* Specify sys.path explicitly */
    /* If you want to modify the default set of paths, finish
       initialization first and then use PySys_GetObject("path") */
    config.module_search_paths_set = 1;
    status = PyWideStringList_Append(&config.module_search_paths,
                                     L"/path/to/stdlib");
    if (PyStatus_Exception(status)) {
        goto done;
    }
    status = PyWideStringList_Append(&config.module_search_paths,
                                     L"/path/to/more/modules");
    if (PyStatus_Exception(status)) {
        goto done;
    }

    /* Override executable computed by PyConfig_Read() */
    status = PyConfig_SetString(&config, &config.executable,
                                L"/path/to/my_executable");
    if (PyStatus_Exception(status)) {
        goto done;
    }

    status = Py_InitializeFromConfig(&config);

done:
    PyConfig_Clear(&config);
    return status;
}
```

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

### Download Python installer layout

Source: https://docs.python.org/3.13/using/windows.html

Downloads all components for an offline installation. Ensure the installer filename matches your specific version.

```shell
python-3.9.0.exe /layout [optional target directory]
```

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

### Example help output

Source: https://docs.python.org/3.13/library/optparse.html

The formatted help text generated by optparse when triggered via the help option or print_help().

```text
Usage: <yourscript> [options] arg1 arg2

Options:
  -h, --help            show this help message and exit
  -v, --verbose         make lots of noise [default]
  -q, --quiet           be vewwy quiet (I'm hunting wabbits)
  -f FILE, --filename=FILE
                        write output to FILE
  -m MODE, --mode=MODE  interaction mode: novice, intermediate, or
                        expert [default: intermediate]
```

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

### Get absolute script path

Source: https://docs.python.org/3.13/whatsnew/changelog.html

The script filename provided on the command line is resolved to an absolute path.

```bash
python3 script.py
```

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

### Use simple format strings

Source: https://docs.python.org/3.13/library/string.html

Examples demonstrating positional arguments, keyword arguments, and attribute/index access.

```python
"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.
```

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

### selection_range(start, end)

Source: https://docs.python.org/3.13/library/tkinter.html

Set the selection to include the characters starting with the one indexed by start and ending with the one just before end.

```APIDOC
## selection_range(start, end)

### Description
Set the selection to include the characters starting with the one indexed by start and ending with the one just before end.
```

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

### Initialize Enum with start parameter

Source: https://docs.python.org/3.13/whatsnew/3.5.html

Use the start parameter in the Enum constructor to define the starting integer value for members when only names are provided.

```python
>>> Animal = enum.Enum('Animal', 'cat dog', start=10)
>>> Animal.cat
<Animal.cat: 10>
>>> Animal.dog
<Animal.dog: 11>
```

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

### Full logging configuration example

Source: https://docs.python.org/3.13/howto/logging-cookbook.html

A complete script demonstrating dictionary-based logging configuration with custom filters and multiple handlers.

```python
import json
import logging
import logging.config

CONFIG = '''
{
    "version": 1,
    "disable_existing_loggers": false,
    "formatters": {
        "simple": {
            "format": "%(levelname)-8s - %(message)s"
        }
    },
    "filters": {
        "warnings_and_below": {
            "()" : "__main__.filter_maker",
            "level": "WARNING"
        }
    },
    "handlers": {
        "stdout": {
            "class": "logging.StreamHandler",
            "level": "INFO",
            "formatter": "simple",
            "stream": "ext://sys.stdout",
            "filters": ["warnings_and_below"]
        },
        "stderr": {
            "class": "logging.StreamHandler",
            "level": "ERROR",
            "formatter": "simple",
            "stream": "ext://sys.stderr"
        },
        "file": {
            "class": "logging.FileHandler",
            "formatter": "simple",
            "filename": "app.log",
            "mode": "w"
        }
    },
    "root": {
        "level": "DEBUG",
        "handlers": [
            "stderr",
            "stdout",
            "file"
        ]
    }
}
'''

def filter_maker(level):
    level = getattr(logging, level)

    def filter(record):
        return record.levelno <= level

    return filter

logging.config.dictConfig(json.loads(CONFIG))
logging.debug('A DEBUG message')
logging.info('An INFO message')
logging.warning('A WARNING message')
logging.error('An ERROR message')
logging.critical('A CRITICAL message')
```

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

### Create and Write an INI Configuration File

Source: https://docs.python.org/3.13/library/configparser.html

Demonstrates how to initialize a ConfigParser, populate it with sections and keys, and write the configuration to a file.

```python
>>> import configparser
>>> config = configparser.ConfigParser()
>>> config['DEFAULT'] = {'ServerAliveInterval': '45',
...                      'Compression': 'yes',
...                      'CompressionLevel': '9'}
>>> config['forge.example'] = {}
>>> config['forge.example']['User'] = 'hg'
>>> config['topsecret.server.example'] = {}
>>> topsecret = config['topsecret.server.example']
>>> topsecret['Port'] = '50022'     # mutates the parser
>>> topsecret['ForwardX11'] = 'no'  # same here
>>> config['DEFAULT']['ForwardX11'] = 'yes'
>>> with open('example.ini', 'w') as configfile:
...   config.write(configfile)
...
```

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

### Running a Server with serve_forever

Source: https://docs.python.org/3.13/library/asyncio-eventloop.html

Shows how to start a server and keep it running until the task is cancelled.

```python
async def client_connected(reader, writer):
    # Communicate with the client with
    # reader/writer streams.  For example:
    await reader.readline()

async def main(host, port):
    srv = await asyncio.start_server(
        client_connected, host, port)
    await srv.serve_forever()

asyncio.run(main('127.0.0.1', 0))
```

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

### Automated macOS Python Installation

Source: https://docs.python.org/3.13/using/mac.html

Uses the macOS installer utility to install a specific Python package with custom configuration via a plist file.

```bash
RELEASE="python-3.130b2-macos11.pkg"

# download installer pkg
curl -O https://www.python.org/ftp/python/3.13.0/${RELEASE}

# create installer choicechanges to customize the install:
#    enable the PythonTFramework-3.13 package
#    while accepting the other defaults (install all other packages)
cat > ./choicechanges.plist <<EOF
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<array>
        <dict>
                <key>attributeSetting</key>
                <integer>1</integer>
                <key>choiceAttribute</key>
                <string>selected</string>
                <key>choiceIdentifier</key>
                <string>org.python.Python.PythonTFramework-3.13</string>
        </dict>
</array>
</plist>
EOF

sudo installer -pkg ./${RELEASE} -applyChoiceChangesXML ./choicechanges.plist -target /
```

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

### Implement setUp for test fixtures

Source: https://docs.python.org/3.13/library/unittest.html

Use the setUp method to factor out repetitive initialization code for multiple test methods.

```python
import unittest

class WidgetTestCase(unittest.TestCase):
    def setUp(self):
        self.widget = Widget('The widget')

    def test_default_widget_size(self):
        self.assertEqual(self.widget.size(), (50,50),
                         'incorrect default size')

    def test_widget_resize(self):
        self.widget.resize(100,150)
        self.assertEqual(self.widget.size(), (100,150),
                         'wrong size after resize')
```

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

### patch.stopall()

Source: https://docs.python.org/3.13/library/unittest.mock.html

Utility to stop all active patches that were started with start().

```APIDOC
## patch.stopall()

### Description
Stops all active patches that have been started using the start() method.
```

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

### Basic argparse setup

Source: https://docs.python.org/3.13/howto/argparse.html

A minimal script demonstrating the default behavior of an argparse parser.

```python
import argparse
parser = argparse.ArgumentParser()
parser.parse_args()
```

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

### Extend EnvBuilder to install packages

Source: https://docs.python.org/3.13/library/venv.html

Subclass venv.EnvBuilder to automate the installation of setuptools and pip during virtual environment creation. The post_setup method is overridden to trigger the installation process.

```python
import os
import os.path
from subprocess import Popen, PIPE
import sys
from threading import Thread
from urllib.parse import urlsplit
from urllib.request import urlretrieve
import venv

class ExtendedEnvBuilder(venv.EnvBuilder):
    """
    This builder installs setuptools and pip so that you can pip or
    easy_install other packages into the created virtual environment.

    :param nodist: If true, setuptools and pip are not installed into the
                   created virtual environment.
    :param nopip: If true, pip is not installed into the created
                  virtual environment.
    :param progress: If setuptools or pip are installed, the progress of the
                     installation can be monitored by passing a progress
                     callable. If specified, it is called with two
                     arguments: a string indicating some progress, and a
                     context indicating where the string is coming from.
                     The context argument can have one of three values:
                     'main', indicating that it is called from virtualize()
                     itself, and 'stdout' and 'stderr', which are obtained
                     by reading lines from the output streams of a subprocess
                     which is used to install the app.

                     If a callable is not specified, default progress
                     information is output to sys.stderr.
    """

    def __init__(self, *args, **kwargs):
        self.nodist = kwargs.pop('nodist', False)
        self.nopip = kwargs.pop('nopip', False)
        self.progress = kwargs.pop('progress', None)
        self.verbose = kwargs.pop('verbose', False)
        super().__init__(*args, **kwargs)

    def post_setup(self, context):
        """
        Set up any packages which need to be pre-installed into the
        virtual environment being created.

        :param context: The information for the virtual environment
                        creation request being processed.
        """
        os.environ['VIRTUAL_ENV'] = context.env_dir
        if not self.nodist:
            self.install_setuptools(context)
        # Can't install pip without setuptools
        if not self.nopip and not self.nodist:
            self.install_pip(context)

    def reader(self, stream, context):
        """
        Read lines from a subprocess' output stream and either pass to a progress
        callable (if specified) or write progress information to sys.stderr.
        """
        progress = self.progress
        while True:
            s = stream.readline()
            if not s:
                break
            if progress is not None:
                progress(s, context)
            else:
                if not self.verbose:
                    sys.stderr.write('.')
                else:
                    sys.stderr.write(s.decode('utf-8'))
                sys.stderr.flush()
        stream.close()

    def install_script(self, context, name, url):
        _, _, path, _, _ = urlsplit(url)
        fn = os.path.split(path)[-1]
        binpath = context.bin_path
        distpath = os.path.join(binpath, fn)
        # Download script into the virtual environment's binaries folder
        urlretrieve(url, distpath)
        progress = self.progress
        if self.verbose:
            term = '\n'
        else:
            term = ''
        if progress is not None:
            progress('Installing %s ...%s' % (name, term), 'main')
        else:
            sys.stderr.write('Installing %s ...%s' % (name, term))
            sys.stderr.flush()
        # Install in the virtual environment
        args = [context.env_exe, fn]
        p = Popen(args, stdout=PIPE, stderr=PIPE, cwd=binpath)
        t1 = Thread(target=self.reader, args=(p.stdout, 'stdout'))
        t1.start()
        t2 = Thread(target=self.reader, args=(p.stderr, 'stderr'))
        t2.start()
        p.wait()
        t1.join()
        t2.join()
        if progress is not None:
            progress('done.', 'main')
        else:
            sys.stderr.write('done.\n')
        # Clean up - no longer needed
        os.unlink(distpath)

    def install_setuptools(self, context):
        """
        Install setuptools in the virtual environment.

```

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

### Install a package from PyPI

Source: https://docs.python.org/3.13/installing/index.html

Installs the latest version of a module and its dependencies.

```bash
python -m pip install SomePackage
```

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

### Run http.server from command line

Source: https://docs.python.org/3.13/library/http.server.html

Basic syntax for starting the HTTP server from the command line.

```bash
python -m http.server [OPTIONS] [port]
```

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

### Equivalent implementation of Py_Main

Source: https://docs.python.org/3.13/c-api/init.html

Demonstrates the approximate sequence of configuration and execution steps performed by Py_Main.

```c
PyConfig config;
PyConfig_InitPythonConfig(&config);
PyConfig_SetArgv(&config, argc, argv);
Py_InitializeFromConfig(&config);
PyConfig_Clear(&config);

Py_RunMain();
```

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

### Examples of Imaginary Literals

Source: https://docs.python.org/3.13/reference/lexical_analysis.html

Valid examples of imaginary literals in Python code.

```python
3.14j   10.j    10j     .001j   1e100j   3.14e-10j   3.14_15_93j
```

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

### Create a simple WSGI server

Source: https://docs.python.org/3.13/library/wsgiref.html

Demonstrates a basic WSGI application that prints the environment dictionary and serves it using make_server.

```python
def simple_app(environ, start_response):
    setup_testing_defaults(environ)

    status = '200 OK'
    headers = [('Content-type', 'text/plain; charset=utf-8')]

    start_response(status, headers)

    ret = [("%s: %s\n" % (key, value)).encode("utf-8")
           for key, value in environ.items()]
    return ret

with make_server('', 8000, simple_app) as httpd:
    print("Serving on port 8000...")
    httpd.serve_forever()
```

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

### Setting up an Importer

Source: https://docs.python.org/3.13/library/importlib.html

Initializes the necessary modules for creating custom meta path or path entry finders.

```python
import importlib.machinery
import sys
```

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

### Standard output of Pool example

Source: https://docs.python.org/3.13/library/multiprocessing.html

The expected output from the Pool parallelization example.

```text
[1, 4, 9]
```

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

### Configure test discovery with arguments

Source: https://docs.python.org/3.13/library/unittest.html

Demonstrates equivalent ways to pass start directory and file pattern arguments to the discovery command.

```bash
python -m unittest discover -s project_directory -p "*_test.py"
python -m unittest discover project_directory "*_test.py"
```

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

### Install packages with pip

Source: https://docs.python.org/3.13/tutorial/venv.html

Commands for installing, upgrading, and managing package versions.

```bash
(tutorial-env) $ python -m pip install novas
Collecting novas
  Downloading novas-3.1.1.3.tar.gz (136kB)
Installing collected packages: novas
  Running setup.py install for novas
Successfully installed novas-3.1.1.3
```

```bash
(tutorial-env) $ python -m pip install requests==2.6.0
Collecting requests==2.6.0
  Using cached requests-2.6.0-py2.py3-none-any.whl
Installing collected packages: requests
Successfully installed requests-2.6.0
```

```bash
(tutorial-env) $ python -m pip install --upgrade requests
Collecting requests
Installing collected packages: requests
  Found existing installation: requests 2.6.0
    Uninstalling requests-2.6.0:
      Successfully uninstalled requests-2.6.0
Successfully installed requests-2.7.0
```

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

### Install more-itertools

Source: https://docs.python.org/3.13/library/itertools.html

Command to install the more-itertools library for additional itertools recipes.

```bash
python -m pip install more-itertools
```

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

### Initialize the Qt logging window

Source: https://docs.python.org/3.13/howto/logging-cookbook.html

Sets up the main GUI window, configures the QtHandler, and defines the log formatting.

```python
class Window(QtWidgets.QWidget):

    COLORS = {
        logging.DEBUG: 'black',
        logging.INFO: 'blue',
        logging.WARNING: 'orange',
        logging.ERROR: 'red',
        logging.CRITICAL: 'purple',
    }

    def __init__(self, app):
        super().__init__()
        self.app = app
        self.textedit = te = QtWidgets.QPlainTextEdit(self)
        # Set whatever the default monospace font is for the platform
        f = QtGui.QFont('nosuchfont')
        if hasattr(f, 'Monospace'):
            f.setStyleHint(f.Monospace)
        else:
            f.setStyleHint(f.StyleHint.Monospace)  # for Qt6
        te.setFont(f)
        te.setReadOnly(True)
        PB = QtWidgets.QPushButton
        self.work_button = PB('Start background work', self)
        self.log_button = PB('Log a message at a random level', self)
        self.clear_button = PB('Clear log window', self)
        self.handler = h = QtHandler(self.update_status)
        # Remember to use qThreadName rather than threadName in the format string.
        fs = '%(asctime)s %(qThreadName)-12s %(levelname)-8s %(message)s'
        formatter = logging.Formatter(fs)
        h.setFormatter(formatter)
        logger.addHandler(h)
        # Set up to terminate the QThread when we exit
        app.aboutToQuit.connect(self.force_quit)

        # Lay out all the widgets
        layout = QtWidgets.QVBoxLayout(self)
        layout.addWidget(te)
        layout.addWidget(self.work_button)
        layout.addWidget(self.log_button)
        layout.addWidget(self.clear_button)
        self.setFixedSize(900, 400)

        # Connect the non-worker slots and signals
        self.log_button.clicked.connect(self.manual_update)
        self.clear_button.clicked.connect(self.clear_display)
```

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

### Create a minimal setup.py for Python modules

Source: https://docs.python.org/3.13/whatsnew/2.0.html

Use this script for packages containing only .py files.

```python
from distutils.core import setup
setup (name = "foo", version = "1.0",
       py_modules = ["module1", "module2"])
```

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

### Install gettext globally

Source: https://docs.python.org/3.13/library/gettext.html

Install the _() function into the built-in namespace for application-wide localization.

```python
import gettext
gettext.install('myapplication')
```

```python
import gettext
gettext.install('myapplication', '/usr/share/locale')
```

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

### multiprocessing.get_start_method(allow_none=False)

Source: https://docs.python.org/3.13/library/multiprocessing.html

Returns the name of the start method used for starting processes.

```APIDOC
## multiprocessing.get_start_method(allow_none=False)

### Description
Return the name of start method used for starting processes.
```

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

### List configure script options

Source: https://docs.python.org/3.13/using/configure.html

Displays all available configuration options for the build process.

```bash
./configure --help
```

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

### Parse command line arguments for store action

Source: https://docs.python.org/3.13/library/optparse.html

Example command line input for the defined store options.

```text
-f foo.txt -p 1 -3.5 4 -fbar.txt
```

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

### Manager output example

Source: https://docs.python.org/3.13/whatsnew/2.6.html

Expected output format for the shared dictionary manager example.

```text
1 1
11 39916800
21 51090942171709440000
31 8222838654177922817725562880000000
41 33452526613163807108170062053440751665152000000000
51 15511187532873822802242430164693032110632597200169861120000...
```

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

### Create and run a WSGI server with make_server

Source: https://docs.python.org/3.13/library/wsgiref.html

Uses make_server to initialize a server instance and process requests using the demo_app.

```python
from wsgiref.simple_server import make_server, demo_app

with make_server('', 8000, demo_app) as httpd:
    print("Serving HTTP on port 8000...")

    # Respond to requests until process is killed
    httpd.serve_forever()

    # Alternative: serve one request, then exit
    httpd.handle_request()
```

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

### Pool output example

Source: https://docs.python.org/3.13/whatsnew/2.6.html

Expected output format for the factorial calculation pool example.

```text
1
39916800
51090942171709440000
8222838654177922817725562880000000
33452526613163807108170062053440751665152000000000
...
```

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

### CSV Data Format Examples

Source: https://docs.python.org/3.13/whatsnew/2.3.html

Examples of simple and complex comma-separated data formats.

```text
Costs,150,200,3.95
```

```text
"Costs",150,200,3.95,"Includes taxes, shipping, and sundry items"
```

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

### Initialize Python with a custom program name

Source: https://docs.python.org/3.13/c-api/init_config.html

Demonstrates basic initialization by setting the program name and handling potential status exceptions.

```c
void init_python(void)
{
    PyStatus status;

    PyConfig config;
    PyConfig_InitPythonConfig(&config);

    /* Set the program name. Implicitly preinitialize Python. */
    status = PyConfig_SetString(&config, &config.program_name,
                                L"/path/to/my_program");
    if (PyStatus_Exception(status)) {
        goto exception;
    }

    status = Py_InitializeFromConfig(&config);
    if (PyStatus_Exception(status)) {
        goto exception;
    }
    PyConfig_Clear(&config);
    return;

exception:
    PyConfig_Clear(&config);
    Py_ExitStatusException(status);
}
```

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

### Instantiating Concrete Paths

Source: https://docs.python.org/3.13/library/pathlib.html

Examples of creating Path, PosixPath, and WindowsPath objects.

```python
>>> Path('setup.py')
PosixPath('setup.py')
```

```python
>>> PosixPath('/etc/hosts')
PosixPath('/etc/hosts')
```

```python
>>> WindowsPath('c:/', 'Users', 'Ximénez')
WindowsPath('c:/Users/Ximénez')
```

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

### Print output example

Source: https://docs.python.org/3.13/whatsnew/3.0.html

Example output produced by the print function with custom separator.

```text
There are <4294967296> possibilities!
```

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

### Icon language generator example

Source: https://docs.python.org/3.13/whatsnew/2.2.html

An example of generator usage in the Icon programming language.

```icon
sentence := "Store it in the neighboring harbor"
if (i := find("or", sentence)) > 5 then write(i)
```

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

### TokenError Example: Unclosed Expression

Source: https://docs.python.org/3.13/library/tokenize.html

Example of a TokenError triggered by an unterminated list expression.

```python
[1,
 2,
 3

```

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

### Implement main entry point for environment creation

Source: https://docs.python.org/3.13/library/venv.html

This function sets up an argument parser to handle configuration flags for creating virtual environments and instantiates the custom builder.

```python
def main(args=None):
    import argparse

    parser = argparse.ArgumentParser(prog=__name__,
                                     description='Creates virtual Python '
                                                 'environments in one or '
                                                 'more target '
                                                 'directories.')
    parser.add_argument('dirs', metavar='ENV_DIR', nargs='+',
                        help='A directory in which to create the '
                             'virtual environment.')
    parser.add_argument('--no-setuptools', default=False,
                        action='store_true', dest='nodist',
                        help="Don't install setuptools or pip in the "
                             "virtual environment.")
    parser.add_argument('--no-pip', default=False,
                        action='store_true', dest='nopip',
                        help="Don't install pip in the virtual "
                             "environment.")
    parser.add_argument('--system-site-packages', default=False,
                        action='store_true', dest='system_site',
                        help='Give the virtual environment access to the '
                             'system site-packages dir.')
    if os.name == 'nt':
        use_symlinks = False
    else:
        use_symlinks = True
    parser.add_argument('--symlinks', default=use_symlinks,
                        action='store_true', dest='symlinks',
                        help='Try to use symlinks rather than copies, '
                             'when symlinks are not the default for '
                             'the platform.')
    parser.add_argument('--clear', default=False, action='store_true',
                        dest='clear', help='Delete the contents of the '
                                           'virtual environment '
                                           'directory if it already '
                                           'exists, before virtual '
                                           'environment creation.')
    parser.add_argument('--upgrade', default=False, action='store_true',
                        dest='upgrade', help='Upgrade the virtual '
                                             'environment directory to '
                                             'use this version of '
                                             'Python, assuming Python '
                                             'has been upgraded '
                                             'in-place.')
    parser.add_argument('--verbose', default=False, action='store_true',
                        dest='verbose', help='Display the output '
                                             'from the scripts which '
                                             'install setuptools and pip.')
    options = parser.parse_args(args)
    if options.upgrade and options.clear:
        raise ValueError('you cannot supply --upgrade and --clear together.')
    builder = ExtendedEnvBuilder(system_site_packages=options.system_site,
                                   clear=options.clear,
                                   symlinks=options.symlinks,
                                   upgrade=options.upgrade,
                                   nodist=options.nodist,
                                   nopip=options.nopip,
                                   verbose=options.verbose)
    for d in options.dirs:
        builder.create(d)

if __name__ == '__main__':
    rc = 1
    try:
        main()
        rc = 0
    except Exception as e:
        print('Error: %s' % e, file=sys.stderr)
    sys.exit(rc)
```

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

### TokenError Example: Unclosed Docstring

Source: https://docs.python.org/3.13/library/tokenize.html

Example of a TokenError triggered by an unterminated multi-line docstring.

```python
"""Beginning of
docstring

```

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

### Initialize ConfigParser with Defaults

Source: https://docs.python.org/3.13/library/configparser.html

Demonstrates initializing a ConfigParser instance with default values and reading from a configuration file.

```python
config = configparser.ConfigParser({'bar': 'Life', 'baz': 'hard'})
config.read('example.cfg')

print(config.get('Section1', 'foo'))     # -> "Python is fun!"
config.remove_option('Section1', 'bar')
config.remove_option('Section1', 'baz')
print(config.get('Section1', 'foo'))     # -> "Life is hard!"
```

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

### Indented doctest examples

Source: https://docs.python.org/3.13/library/doctest.html

Illustrates that doctest ignores leading whitespace when identifying examples.

```python
>>> assert "Easy!"
      >>> import math
          >>> math.floor(1.9)
          1
```

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

### Install Python on FreeBSD and OpenBSD

Source: https://docs.python.org/3.13/using/unix.html

Commands to install Python packages on BSD systems.

```bash
pkg install python3
```

```bash
pkg_add -r python

pkg_add ftp://ftp.openbsd.org/pub/OpenBSD/4.2/packages/<insert your architecture here>/python-<version>.tgz
```

```bash
pkg_add ftp://ftp.openbsd.org/pub/OpenBSD/4.2/packages/i386/python-2.5.1p2.tgz
```

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

### Create a Listener and Send Data

Source: https://docs.python.org/3.13/library/multiprocessing.html

Demonstrates setting up a listener with an authentication key and sending data to a connected client.

```python
from multiprocessing.connection import Listener
from array import array

address = ('localhost', 6000)     # family is deduced to be 'AF_INET'

with Listener(address, authkey=b'secret password') as listener:
    with listener.accept() as conn:
        print('connection accepted from', listener.last_accepted)

        conn.send([2.25, None, 'junk', float])

        conn.send_bytes(b'hello')
```

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

### Start a Manager Server

Source: https://docs.python.org/3.13/library/multiprocessing.html

Initializes a BaseManager and starts a server process to listen for connections.

```python
>>> from multiprocessing.managers import BaseManager
>>> manager = BaseManager(address=('', 50000), authkey=b'abc')
>>> server = manager.get_server()
>>> server.serve_forever()
```

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

### Create and run an HTTP server

Source: https://docs.python.org/3.13/library/http.server.html

A basic implementation showing how to instantiate and start an HTTPServer using a specified handler class.

```python
def run(server_class=HTTPServer, handler_class=BaseHTTPRequestHandler):
    server_address = ('', 8000)
    httpd = server_class(server_address, handler_class)
    httpd.serve_forever()
```

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

### Perform a basic FTP session

Source: https://docs.python.org/3.13/library/ftplib.html

Demonstrates connecting to a server, logging in, navigating directories, listing contents, and downloading a file.

```python
>>> from ftplib import FTP
>>> ftp = FTP('ftp.us.debian.org')  # connect to host, default port
>>> ftp.login()                     # user anonymous, passwd anonymous@
'230 Login successful.'
>>> ftp.cwd('debian')               # change into "debian" directory
'250 Directory successfully changed.'
>>> ftp.retrlines('LIST')           # list directory contents
-rw-rw-r--    1 1176     1176         1063 Jun 15 10:18 README
...
drwxr-sr-x    5 1176     1176         4096 Dec 19  2000 pool
drwxr-sr-x    4 1176     1176         4096 Nov 17  2008 project
drwxr-xr-x    3 1176     1176         4096 Oct 10  2012 tools
'226 Directory send OK.'
>>> with open('README', 'wb') as fp:
>>>     ftp.retrbinary('RETR README', fp.write)
'226 Transfer complete.'
>>> ftp.quit()
'221 Goodbye.'
```

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

### Perform GET Request with Parameters

Source: https://docs.python.org/3.13/library/urllib.request.html

Uses urlencode to format parameters for a GET request.

```python
>>> import urllib.request
>>> import urllib.parse
>>> params = urllib.parse.urlencode({'spam': 1, 'eggs': 2, 'bacon': 0})
>>> url = "https://www.python.org/?%s" % params
>>> with urllib.request.urlopen(url) as f:
...     print(f.read().decode('utf-8'))
...
```

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

### Tkinter event binding example

Source: https://docs.python.org/3.13/library/tkinter.html

An example of defining a callback function and binding it to a widget event.

```python
def turn_red(self, event):
    event.widget["activeforeground"] = "red"

self.button.bind("<Enter>", self.turn_red)
```

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

### Initialize Repr with keyword arguments

Source: https://docs.python.org/3.13/library/reprlib.html

Demonstrates initializing a Repr instance using keyword arguments as a shortcut.

```python
aRepr = reprlib.Repr(maxlevel=3)
```

```python
aRepr = reprlib.Repr()
aRepr.maxlevel = 3
```

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

### DocTestParser.get_examples(string[, name])

Source: https://docs.python.org/3.13/library/doctest.html

Extracts all doctest examples from a string and returns them as a list of Example objects.

```APIDOC
## DocTestParser.get_examples(string[, name])

### Description
Parses a string and returns a list of Example objects found within it.

### Parameters
- **string** (str) - Required - The string to parse.
- **name** (str) - Optional - Identifier for the string, used in error messages.
```

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

### Initialize and import module

Source: https://docs.python.org/3.13/extending/embedding.html

Snippet showing the initialization of the interpreter and importing a module from a file.

```c
Py_Initialize();
pName = PyUnicode_DecodeFSDefault(argv[1]);
/* Error checking of pName left out */
pModule = PyImport_Import(pName);
```
Tokens:
Raw