Python 3.12

https://docs.python.org/3.12/
Admin
Python 3.12 is a programming language that provides comprehensive documentation covering syntax,...
Tokens:4,422,369
Snippets:39,452
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### site module functions example

Source: https://docs.python.org/3.12/whatsnew/3.2.html

Demonstrates site.getsitepackages(), site.getuserbase(), and site.getusersitepackages() to retrieve installation paths. The output shows example paths on macOS.

```python
>>> import site
>>> site.getsitepackages()
['/Library/Frameworks/Python.framework/Versions/3.2/lib/python3.2/site-packages',
 '/Library/Frameworks/Python.framework/Versions/3.2/lib/site-python',
 '/Library/Python/3.2/site-packages']
>>> site.getuserbase()
'/Users/raymondhettinger/Library/Python/3.2'
>>> site.getusersitepackages()
'/Users/raymondhettinger/Library/Python/3.2/lib/python/site-packages'
```

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

### Using patch.start() in setUp and stop() in tearDown

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

Shows a typical use case for multiple patches in the setUp method of a TestCase, starting patches in setUp and stopping them in tearDown.

```python
>>> class MyTest(unittest.TestCase):
...     def setUp(self):
...         self.patcher1 = patch('package.module.Class1')
...         self.patcher2 = patch('package.module.Class2')
...         self.MockClass1 = self.patcher1.start()
...         self.MockClass2 = self.patcher2.start()
...
...     def tearDown(self):
...         self.patcher1.stop()
...         self.patcher2.stop()
...
...     def test_something(self):
...         assert package.module.Class1 is self.MockClass1
...         assert package.module.Class2 is self.MockClass2
...
>>> MyTest('test_something').run()
```

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

### ThreadPoolExecutor example setup

Source: https://docs.python.org/3.12/library/concurrent.futures.html

Imports and defines a list of URLs for the ThreadPoolExecutor example.

```python
import concurrent.futures
import urllib.request

URLS = ['http://www.foxnews.com/',
        'http://www.cnn.com/',
        'http://europe.wsj.com/',
        'http://www.bbc.co.uk/',
        'http://nonexistant-subdomain.python.org/']
```

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

### Install Python on OpenBSD for i386

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

Example command to install Python 2.5.1 on i386 architecture using pkg_add.

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

```

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

### Using patch start and stop in setUp and tearDown

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

Manage patches manually using patch.start() and patch.stop() in setUp and tearDown. You must ensure stop is called, but if setUp raises an exception, tearDown is not called.

```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()

```

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

### Setting up an importer

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

Starts the example for setting up an importer, importing the necessary modules for custom import machinery.

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

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

### setup() with dependency metadata (PEP 314)

Source: https://docs.python.org/3.12/whatsnew/2.5.html

Example of the setup() function using new keyword parameters requires, obsoletes, and download_url. The download_url uses a format string with the VERSION variable. This is used when building a source distribution with the sdist command.

```python
VERSION = '1.0'
setup(name='PyPackage',
      version=VERSION,
      requires=['numarray', 'zlib (>=1.1.4)'],
      obsoletes=['OldPackage']
      download_url=('http://www.example.com/pypackage/dist/pkg-%s.tar.gz'
                    % VERSION),
     )

```

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

### Cross-compilation machine and OS examples

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

Examples of valid machine and OS combinations for cross-compiling Python to WASM/WASI targets.

```bash
wasm32-unknown-emscripten
```

```bash
wasm32-wasi
```

```bash
wasm32-unknown-wasi
```

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

### ResourceWarning example script

Source: https://docs.python.org/3.12/whatsnew/3.6.html

Example script that triggers a ResourceWarning by not closing a file, used with the command 'python3.6 -Wd -X tracemalloc=5 example.py'.

```python
import warnings

def func():
    return open(__file__)

f = func()
f = None

```

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

### Run Python with -VV to print detailed version information

Source: https://docs.python.org/3.12/whatsnew/3.6.html

When --version (or -V) is supplied twice, Python prints sys.version for detailed information. The example shows the output of ./python -VV, which includes the version, build details, and compiler information.

```shell
$ ./python -VV
Python 3.6.0b4+ (3.6:223967b49e49+, Nov 21 2016, 20:55:04)
[GCC 4.2.1 Compatible Apple LLVM 8.0.0 (clang-800.0.42.1)]

```

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

### ResourceWarning output with tracemalloc

Source: https://docs.python.org/3.12/whatsnew/3.6.html

Output of running the example script with tracemalloc enabled, showing the new 'Object allocated at' traceback.

```python
example.py:7: ResourceWarning: unclosed file <_io.TextIOWrapper name='example.py' mode='r' encoding='UTF-8'>
  f = None
Object allocated at (most recent call first):
  File "example.py", lineno 4
    return open(__file__)
  File "example.py", lineno 6
    f = func()

```

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

### enum.auto example

Source: https://docs.python.org/3.12/whatsnew/3.6.html

Demonstrates using the new enum.auto value to automatically assign values to enum members. The example defines a Color enum with red, blue, and green members, and shows that list(Color) returns members with values 1, 2, and 3.

```python
>>> from enum import Enum, auto
>>> class Color(Enum):
...     red = auto()
...     blue = auto()
...     green = auto()
...
>>> list(Color)
[<Color.red: 1>, <Color.blue: 2>, <Color.green: 3>]
```

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

### Traceback abbreviation example

Source: https://docs.python.org/3.12/whatsnew/3.6.html

Shows how the interpreter abbreviates repeated lines in tracebacks, displaying '[Previous line repeated 995 more times]'.

```python
>>> def f(): f()
...
>>> f()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 1, in f
  File "<stdin>", line 1, in f
  File "<stdin>", line 1, in f
  [Previous line repeated 995 more times]
RecursionError: maximum recursion depth exceeded

```

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

### F-string literal with nested fields

Source: https://docs.python.org/3.12/whatsnew/3.6.html

Demonstrates f-string literals with replacement fields and nested format specifiers. The example shows basic interpolation and nested fields using width and precision.

```python
>>> name = "Fred"
>>> f"He said his name is {name}."
'He said his name is Fred.'
>>> width = 10
>>> precision = 4
>>> value = decimal.Decimal("12.34567")
>>> f"result: {value:{width}.{precision}}"  # nested fields
'result:      12.35'
```

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

### NewType() usage example

Source: https://docs.python.org/3.12/whatsnew/3.6.html

Demonstrates creating a lightweight distinct type with typing.NewType, which static type checkers treat as a subclass of the original type.

```python
from typing import NewType

UserId = NewType('UserId', int)
some_id = UserId(524313)

```

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

### Fatal error output on buffer overflow with PYTHONMALLOC=debug and -X tracemalloc=5

Source: https://docs.python.org/3.12/whatsnew/3.6.html

Example of a fatal error message produced when a buffer overflow is detected by the debug hooks on Python memory allocators. Run with `python3.6 -X tracemalloc=5` to store 5 frames in traces. The output shows the memory block details, the traceback where the block was allocated, and the fatal error message.

```text
Debug memory block at address p=0x7fbcd41666f8: API 'o'
    4 bytes originally requested
    The 7 pad bytes at p-7 are FORBIDDENBYTE, as expected.
    The 8 pad bytes at tail=0x7fbcd41666fc are not all FORBIDDENBYTE (0xfb):
        at tail+0: 0x02 *** OUCH
        at tail+1: 0xfb
        at tail+2: 0xfb
        at tail+3: 0xfb
        at tail+4: 0xfb
        at tail+5: 0xfb
        at tail+6: 0xfb
        at tail+7: 0xfb
    The block was made by call #1233329 to debug malloc/realloc.
    Data at p: 1a 2b 30 00

Memory block allocated at (most recent call first):
  File "test/test_bytes.py", line 323
  File "unittest/case.py", line 600
  File "unittest/case.py", line 648
  File "unittest/suite.py", line 122
  File "unittest/suite.py", line 84

Fatal Python error: bad trailing pad byte

Current thread 0x00007fbcdbd32700 (most recent call first):
  File "test/test_bytes.py", line 323 in test_hex
  File "unittest/case.py", line 600 in run
  File "unittest/case.py", line 648 in __call__
  File "unittest/suite.py", line 122 in run
  File "unittest/suite.py", line 84 in __call__
  File "unittest/suite.py", line 122 in run
  File "unittest/suite.py", line 84 in __call__
  ...
```

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

### setup(width, height, startx, starty)

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

Set the size and position of the main window.

```APIDOC
## setup(width=CFG['width'], height=CFG['height'], startx=CFG['leftright'], starty=CFG['topbottom'])

### Description
Set the size and position of the main window. Default values are stored in the configuration dictionary and can be changed via a turtle.cfg file.

### Method
setup

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

### Example
```
>>> screen.setup(width=200, height=200, startx=0, starty=0)
>>>              # sets window to 200x200 pixels, in upper left of screen
>>> screen.setup(width=.75, height=0.5, startx=None, starty=None)
>>>              # sets window to 75% of screen by 50% of screen and centers
```
```

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

### Get distribution version with importlib.metadata.version

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

Starts a Python interpreter and uses importlib.metadata.version to retrieve the installed version string for the 'wheel' distribution. The output shows the version '0.32.3'.

```python
(example) $ python
>>> from importlib.metadata import version
>>> version('wheel')
'0.32.3'

```

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

### Get HTTP Headers Example

Source: https://docs.python.org/3.12/library/asyncio-stream.html

Example of querying HTTP headers using asyncio streams.

```APIDOC
## Get HTTP Headers Example

### Description
Simple example querying HTTP headers of the URL passed on the command line.

### Code
```python
import asyncio
import urllib.parse
import sys

async def print_http_headers(url):
    url = urllib.parse.urlsplit(url)
    if url.scheme == 'https':
        reader, writer = await asyncio.open_connection(
            url.hostname, 443, ssl=True)
    else:
        reader, writer = await asyncio.open_connection(
            url.hostname, 80)

    query = (
        f"HEAD {url.path or '/'} HTTP/1.0\r\n"
        f"Host: {url.hostname}\r\n"
        f"\r\n"
    )

    writer.write(query.encode('latin-1'))
    while True:
        line = await reader.readline()
        if not line:
            break

        line = line.decode('latin1').rstrip()
        if line:
            print(f'HTTP header> {line}')

    # Ignore the body, close the socket
    writer.close()
    await writer.wait_closed()

url = sys.argv[1]
asyncio.run(print_http_headers(url))
```

### Usage
```bash
python example.py http://example.com/path/page.html
```

or with HTTPS:
```bash
python example.py https://example.com/path/page.html
```
```

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

### Process Example Usage

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

Example usage of Process methods including start, is_alive, terminate, and exitcode.

```APIDOC
## Process Example Usage

### Description
Example usage of some of the methods of Process.

### Code Example
```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
```
```

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

### Invoke the ExampleService demo from the command line

Source: https://docs.python.org/3.12/library/xmlrpc.server.html

Command to run the example server module from the command line using python -m xmlrpc.server.

```bash
python -m xmlrpc.server
```

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

### setup.py for building custom extension

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

Setuptools script to build the extension from custom.c.

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

```

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

### Start tracing for computing differences

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

Start tracing memory allocations with tracemalloc.start(). This is the beginning of the 'Compute differences' example.

```python
import tracemalloc
tracemalloc.start()

```

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

### setup_scripts(context)

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

Installs activation scripts appropriate to the platform into the virtual environment.

```APIDOC
## setup_scripts(context)

### Description
Installs activation scripts appropriate to the platform into the virtual environment.

### Method
setup_scripts

### Parameters
- **context** - Required - The context object for the virtual environment.

```

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

### Enum with start parameter

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

Shows how to create an Enum with a custom starting number using the new start parameter. The example creates an Animal enum with cat=10 and dog=11.

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

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

### os.startfile(path[, operation][, arguments][, cwd][, show_cmd])

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

Documentation for the os.startfile function, which starts a file with its associated application on Windows.

```APIDOC
## os.startfile(path[, operation][, arguments][, cwd][, show_cmd])

### Description
Starts a file with its associated application. When operation is not specified, it acts like double-clicking the file in Windows Explorer or giving the file name as an argument to the start command. When another operation is given, it must be a command verb that specifies what should be done with the file.

### Method
Function call

### Endpoint
os.startfile(path[, operation][, arguments][, cwd][, show_cmd])

### Parameters
#### Path Parameters
- **path** (string) - Required - The path to the file to start. Relative to the current directory or cwd. If using an absolute path, ensure the first character is not a slash ('/').

#### Optional Parameters
- **operation** (string) - Optional - A command verb specifying what should be done with the file. Common verbs include 'open', 'print', 'edit' (for files) and 'explore', 'find' (for directories).
- **arguments** (string) - Optional - Arguments to be passed to the application when launching it. This may have no effect when launching a document.
- **cwd** (string) - Optional - Overrides the default working directory. Should be an absolute path. A relative path will be resolved against this argument.
- **show_cmd** (integer) - Optional - Overrides the default window style. Values are integers as supported by the Win32 ShellExecute() function.

### Request Example
```python
os.startfile('document.txt', 'print')
```

### Response
#### Success Response
Returns as soon as the associated application is launched. There is no option to wait for the application to close, and no way to retrieve the application's exit status.

#### Error Handling
- Raises NotImplementedError if the Win32 ShellExecute() function cannot be resolved.
- Raises auditing events os.startfile with arguments path, operation, and os.startfile/2 with arguments path, operation, arguments, cwd, show_cmd.

### Availability
Windows.

### Notes
Changed in version 3.10: Added the arguments, cwd and show_cmd arguments, and the os.startfile/2 audit event.
```

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

### Set window size and position with setup()

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

Sets the size and position of the main window. Width and height can be integers (pixels) or floats (fraction of screen). startx/starty can be positive (from left/top), negative (from right/bottom), or None to center.

```python
>>> screen.setup (width=200, height=200, startx=0, starty=0)
>>>              # sets window to 200x200 pixels, in upper left of screen
>>> screen.setup(width=.75, height=0.5, startx=None, starty=None)
>>>              # sets window to 75% of screen by 50% of screen and centers
```

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

### await_args_list example

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

Shows how await_args_list accumulates all awaits in sequence. The example starts with an empty list, then appends a call after each await.

```python
>>> mock = AsyncMock()
>>> async def main(*args):
...     await mock(*args)
...
>>> mock.await_args_list
[]
>>> asyncio.run(main('foo'))
>>> mock.await_args_list
[call('foo')]
>>> asyncio.run(main('bar'))
>>> mock.await_args_list
[call('foo'), call('bar')]
```

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

### Get distribution version with version()

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

Returns the installed version of the 'wheel' distribution as a string. Raises PackageNotFoundError if the package is not installed.

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

```

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

### Set up a WSGI server with wsgiref

Source: https://docs.python.org/3.12/whatsnew/2.5.html

Minimal example of creating a WSGI server using wsgiref.simple_server. The server runs on the given host and port, serving the provided WSGI application. Intended for debugging, not production.

```python
from wsgiref import simple_server

wsgi_app = ...

host = ''
port = 8000
httpd = simple_server.make_server(host, port, wsgi_app)
httpd.serve_forever()
```

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

### ^ anchor example: matching at line start

Source: https://docs.python.org/3.12/howto/regex.html

Demonstrates the ^ metacharacter, which matches at the beginning of a line. In the first call, the pattern matches at the start of the string; in the second, it does not because the string does not start with 'From'.

```python
>>> print(re.search('^From', 'From Here to Eternity'))
<re.Match object; span=(0, 4), match='From'>
>>> print(re.search('^From', 'Reciting From Memory'))
None
```

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

### Start the Python interpreter with python3.12

Source: https://docs.python.org/3.12/tutorial/interpreter.html

Type this command in a Unix shell to start the Python interpreter. The interpreter is usually installed at /usr/local/bin/python3.12.

```shell
python3.12

```

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

### post_setup(context)

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

A placeholder method which can be overridden in third party implementations to pre-install packages in the virtual environment or perform other post-creation steps.

```APIDOC
## post_setup(context)

### Description
A placeholder method which can be overridden in third party implementations to pre-install packages in the virtual environment or perform other post-creation steps.

### Method
post_setup

### Parameters
- **context** - Required - The context object for the virtual environment.

```

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

### setup_python(context)

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

Creates a copy or symlink to the Python executable in the environment.

```APIDOC
## setup_python(context)

### Description
Creates a copy or symlink to the Python executable in the environment. On POSIX systems, if a specific executable python3.x was used, symlinks to python and python3 will be created pointing to that executable, unless files with those names already exist.

### Parameters
- **context** (SimpleNamespace) - Required - The context object returned by ensure_directories().
```

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

### Imports for queue-based worker process example

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

Starts an example showing how to use queues to feed tasks to worker processes and collect results. This snippet only contains the imports; the full example continues in the source.

```python
import time
import random

from multiprocessing import Process, Queue, current_process, freeze_support

```

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

### Python interface: Timer with gc.enable() in setup

Source: https://docs.python.org/3.12/library/timeit.html

Example from the note about garbage collection: re-enable GC as the first statement in the setup string to measure its impact.

```python
timeit.Timer('for i in range(10): oct(i)', 'gc.enable()').timeit()
```

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

### Import setup_testing_defaults and make_server

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

Import the setup_testing_defaults function and the make_server function from wsgiref.simple_server. This is the beginning of an example that sets up a dummy WSGI environment for testing purposes.

```python
from wsgiref.util import setup_testing_defaults
from wsgiref.simple_server import make_server

```

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

### modules_setup

Source: https://docs.python.org/3.12/library/test.html

Returns a copy of sys.modules.

```APIDOC
## [FUNCTION] modules_setup

### Description
Returns a copy of sys.modules.

### Returns
A dictionary copy of sys.modules.
```

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

### PyUnicodeDecodeError_GetStart / PyUnicodeEncodeError_GetStart / PyUnicodeTranslateError_GetStart

Source: https://docs.python.org/3.12/c-api/exceptions.html

Gets the start attribute of the given exception object.

```APIDOC
## PyUnicodeDecodeError_GetStart

### Description
Gets the start attribute of the given exception object and places it into *start.

### Signature
`int PyUnicodeDecodeError_GetStart(PyObject *exc, Py_ssize_t *start)`

### Parameters
- **exc** (PyObject*) - Required - The exception object.
- **start** (Py_ssize_t*) - Required - Pointer to store the start attribute. Must not be NULL.

### Return Value
Returns 0 on success, -1 on failure. Part of the Stable ABI.
```

```APIDOC
## PyUnicodeEncodeError_GetStart

### Description
Gets the start attribute of the given exception object and places it into *start.

### Signature
`int PyUnicodeEncodeError_GetStart(PyObject *exc, Py_ssize_t *start)`

### Parameters
- **exc** (PyObject*) - Required - The exception object.
- **start** (Py_ssize_t*) - Required - Pointer to store the start attribute. Must not be NULL.

### Return Value
Returns 0 on success, -1 on failure. Part of the Stable ABI.
```

```APIDOC
## PyUnicodeTranslateError_GetStart

### Description
Gets the start attribute of the given exception object and places it into *start.

### Signature
`int PyUnicodeTranslateError_GetStart(PyObject *exc, Py_ssize_t *start)`

### Parameters
- **exc** (PyObject*) - Required - The exception object.
- **start** (Py_ssize_t*) - Required - Pointer to store the start attribute. Must not be NULL.

### Return Value
Returns 0 on success, -1 on failure. Part of the Stable ABI.
```

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

### setup.py for packages

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

setup.py for a distribution containing a few packages. Use this when the software consists of packages and subpackages.

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

```

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

### itertools.count() examples

Source: https://docs.python.org/3.12/howto/functional.html

Shows how to use itertools.count() with optional start and step arguments to generate infinite arithmetic progressions. The default start is 0 and default step is 1.

```python
itertools.count() =>
  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...
itertools.count(10) =>
  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ...
itertools.count(10, 5) =>
  10, 15, 20, 25, 30, 35, 40, 45, 50, 55, ...
```

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

### Multiprocessing logging with QueueHandler and listener process

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

This example shows a multiprocessing logging setup where a listener process receives log records from worker processes via a queue. The worker_configurer function sets up a QueueHandler, and the main function orchestrates the listener and workers. Note that on Windows, fork semantics cannot be relied upon, so each process runs the logging configuration code when it starts.

```python
MESSAGES = [
    'Random message #1',
    'Random message #2',
    'Random message #3',
]

# The worker configuration is done at the start of the worker process run.
# Note that on Windows you can't rely on fork semantics, so each process
# will run the logging configuration code when it starts.
def worker_configurer(queue):
    h = logging.handlers.QueueHandler(queue)  # Just the one handler needed
    root = logging.getLogger()
    root.addHandler(h)
    # send all messages, for demo; no other level or filter logic applied.
    root.setLevel(logging.DEBUG)

# This is the worker process top-level loop, which just logs ten events with
# random intervening delays before terminating.
# The print messages are just so you know it's doing something!
def worker_process(queue, configurer):
    configurer(queue)
    name = multiprocessing.current_process().name
    print('Worker started: %s' % name)
    for i in range(10):
        time.sleep(random())
        logger = logging.getLogger(choice(LOGGERS))
        level = choice(LEVELS)
        message = choice(MESSAGES)
        logger.log(level, message)
    print('Worker finished: %s' % name)

# Here's where the demo gets orchestrated. Create the queue, create and start
# the listener, create ten workers and start them, wait for them to finish,
# then send a None to the queue to tell the listener to finish.
def main():
    queue = multiprocessing.Queue(-1)
    listener = multiprocessing.Process(target=listener_process,
                                       args=(queue, listener_configurer))
    listener.start()
    workers = []
    for i in range(10):
        worker = multiprocessing.Process(target=worker_process,
                                         args=(queue, worker_configurer))
        workers.append(worker)
        worker.start()
    for w in workers:
        w.join()
    queue.put_nowait(None)
    listener.join()

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