Python Standard Library

https://docs.python.org/3.13/library/
Admin
The Python Standard Library is a comprehensive collection of modules distributed with Python,...
Tokens:2,839,825
Snippets:19,999
Trust Score:10
Update:6 days ago
Show doc for...
Tokens:
Raw
### Using patch start and stop in setUp and tearDown

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

Manages patching by starting the patcher in setUp and stopping it in tearDown. This requires explicit stop to undo the patch, which can be problematic if setUp raises an exception.

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

```

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

### Create virtual environment and install wheel

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

Sets up a virtual environment and installs the 'wheel' package using pip, which is a prerequisite for the subsequent examples.

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

```

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

### distribution('wheel') example

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

Shows how to get a Distribution instance for an installed distribution package using the distribution() function. The example uses 'wheel' and shows the resulting type is importlib.metadata.PathDistribution.

```python
>>> from importlib.metadata import distribution
>>> dist = distribution('wheel')
>>> type(dist)
<class 'importlib.metadata.PathDistribution'>
```

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

### Basic INI configuration file example

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

A sample INI file showing the structure with a DEFAULT section and two sections. Used as the basis for the quick start examples.

```ini
[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes

[forge.example]
User = hg

[topsecret.server.example]
Port = 50022
ForwardX11 = no

```

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

### Using start() and stop() in setUp and tearDown for multiple patches

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

A typical use case for multiple patches in the setUp method of a TestCase. The patchers are started in setUp and stopped in tearDown. Note that if an exception is raised in setUp, tearDown is not called, so patching may not be undone.

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

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

### timeit.timeit() with setup import from __main__

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

Shows how to give timeit access to functions defined in the script by passing a setup parameter with an import statement. The example defines a test function and times it using timeit.timeit().

```python
def test():
    """Stupid test function"""
    L = [i for i in range(100)]

if __name__ == '__main__':
    import timeit
    print(timeit.timeit("test()", setup="from __main__ import test"))
```

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

### Trivial Process example

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

Minimal example of spawning a process using Process and calling start() and join(). The target function prints a greeting.

```python
from multiprocessing import Process

def f(name):
    print('hello', name)

if __name__ == '__main__':
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

```

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

### timeit -s setup statement command-line examples

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

Shows how to use the -s option to provide a setup statement executed once at the beginning. The output includes loop count, repetition count ('best of 5'), and average time per loop in the best repetition.

```bash
$ python -m timeit -s "text = 'sample string'; char = 'g'" "char in text"
5000000 loops, best of 5: 0.0877 usec per loop
$ python -m timeit -s "text = 'sample string'; char = 'g'" "text.find(char)"
1000000 loops, best of 5: 0.342 usec per loop
```

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

### Select start method with set_start_method('spawn')

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

Use set_start_method() in the if __name__ == '__main__' clause to select a start method. This example uses 'spawn'. set_start_method() should not be called more than once in the program.

```python
import multiprocessing as mp

def foo(q):
    q.put('hello')

if __name__ == '__main__':
    mp.set_start_method('spawn')
    q = mp.Queue()
    p = mp.Process(target=foo, args=(q,))
    p.start()
    print(q.get())
    p.join()

```

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

### Setting up an importer with importlib.machinery

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

Starts the example for registering custom importers, showing the initial imports of importlib.machinery and sys. The full importer implementation is not shown in this snippet.

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

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

### Configure Screen Setup

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

Examples of setting the turtle graphics window size and position using pixel values or screen fractions.

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

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

### GET request example using http.client

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

Shows a session using the GET method with HTTPSConnection. Demonstrates reading the entire response, reading in chunks, and handling an invalid request that returns 404.

```python
>>> import http.client
>>> conn = http.client.HTTPSConnection("www.python.org")
>>> conn.request("GET", "/")
>>> r1 = conn.getresponse()
>>> print(r1.status, r1.reason)
200 OK
>>> data1 = r1.read()  # This will return entire content.
>>> # The following example demonstrates reading data in chunks.
>>> conn.request("GET", "/")
>>> r1 = conn.getresponse()
>>> while chunk := r1.read(200):
...     print(repr(chunk))
b'<!doctype html>\n<!--[if"...
...
>>> # Example of an invalid request
>>> conn = http.client.HTTPSConnection("docs.python.org")
>>> conn.request("GET", "/parrot.spam")
>>> r2 = conn.getresponse()
>>> print(r2.status, r2.reason)
404 Not Found
>>> data2 = r2.read()
>>> conn.close()
```

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

### Example usage of setup_testing_defaults

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

Shows how to import and use setup_testing_defaults from wsgiref.util. The example is incomplete as it only shows the import statements.

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

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

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

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

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.

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

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

### Method
Function call

### Endpoint
`turtle.setup(_width =_CFG['width']_, _height =_CFG['height']_, _startx =_CFG['leftright']_, _starty =_CFG['topbottom']_)`

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

### Request 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
```

### Response
No return value.
```

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

### Change Combobox theme settings with style.theme_settings

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

Example from the theme_settings() documentation. It creates a Tk root, gets the ttk.Style, and applies custom padding, background, fieldbackground, and foreground mappings to the 'TCombobox' style for the 'default' theme. The example then creates a Combobox and starts the main loop.

```python
from tkinter import ttk
import tkinter

root = tkinter.Tk()

style = ttk.Style()
style.theme_settings("default", {
   "TCombobox": {
       "configure": {"padding": 5},
       "map": {
           "background": [("active", "green2"),
                          ("!disabled", "green4")],
           "fieldbackground": [("!disabled", "green3")],
           "foreground": [("focus", "OliveDrab1"),
                          ("!disabled", "OliveDrab2")]
       }
   }
})

combo = ttk.Combobox().pack()

root.mainloop()
```

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

### TestCase with setUp() for fixture setup

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

Uses setUp() to create a widget before each test. Tests default size and resize behavior.

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

```

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

### Server.start_serving()

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

Starts accepting connections on the server.

```APIDOC
## Server.start_serving()

### Description
Starts accepting connections. This method is idempotent, so it can be called when the server is already serving. Useful when the server was created with `start_serving=False`.

### Method
async start_serving()

### Parameters
None

### Returns
None

### Example
```python
await server.start_serving()
```
```

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

### Get Linux distribution IDs using platform.freedesktop_os_release()

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

Example function that calls platform.freedesktop_os_release() to retrieve the OS identification dictionary, then builds a list of distribution IDs starting with the 'ID' field and extending with space-separated values from 'ID_LIKE' if present. The 'ID_LIKE' field is optional and its values are ordered by precedence.

```python
def get_like_distro():
    info = platform.freedesktop_os_release()
    ids = [info["ID"]]
    if "ID_LIKE" in info:
        # ids are space separated and ordered by precedence
        ids.extend(info["ID_LIKE"].split())
    return ids

```

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

### Create and write a configuration file programmatically

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

Shows how to create a ConfigParser, populate sections and keys like a dictionary, and write to 'example.ini'. The DEFAULT section provides defaults for all other sections.

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

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

### Output of handler example

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

Output produced by the handler example program, showing the sequence of start, character data, and end events.

```text
Start element: parent {'id': 'top'}
Start element: child1 {'name': 'paul'}
Character data: 'Text goes here'
End element: child1
Character data: '\n'
Start element: child2 {'name': 'fred'}
Character data: 'More text'
End element: child2
Character data: '\n'
End element: parent

```

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

### Create and start threads with threading.Thread

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

Basic example of creating and starting threads using the Thread class. It defines a crawl function that simulates blocking I/O with time.sleep, then starts a thread for each link in a list, passing positional arguments via args and keyword arguments via kwargs. The example is from the introduction section of the threading module documentation.

```python
import threading
import time

def crawl(link, delay=3):
    print(f"crawl started for {link}")
    time.sleep(delay)  # Blocking I/O (simulating a network request)
    print(f"crawl ended for {link}")

links = [
    "https://python.org",
    "https://docs.python.org",
    "https://peps.python.org",
]

# Start threads for each link
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)
```

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

### EnvBuilder.setup_scripts(context)

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

Installs activation scripts appropriate to the platform into the virtual environment. This method is part of the EnvBuilder class.

```APIDOC
## EnvBuilder.setup_scripts(context)

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

### Method
setup_scripts

### Parameters
- **context** (object) - Required - The context object representing the environment creation process.

### Response
No return value.
```

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

### urljoin example: absolute URL with //

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

Shows that if the url argument starts with //, the result includes the hostname from the url. This example demonstrates the behavior.

```python
>>> urljoin('http://www.cwi.nl/%7Eguido/Python.html',
...         '//www.python.org/%7Eguido')
'http://www.python.org/%7Eguido'
```

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

### timeit.timeit() with setup parameter

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

Demonstrates the timeit.timeit() function with a setup parameter. The output shows the average execution time in seconds for each statement.

```python
>>> import timeit
>>> timeit.timeit('char in text', setup='text = "sample string"; char = "g"')
0.41440500499993504
>>> timeit.timeit('text.find(char)', setup='text = "sample string"; char = "g"')
1.7246671520006203
```

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

### Get distribution version with version('wheel')

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

The version() function returns the installed distribution package version as a string. Raises PackageNotFoundError if the distribution is not installed.

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

```

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

### EnvBuilder.post_setup(context)

Source: https://docs.python.org/3.13/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
## EnvBuilder.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** (object) - Required - The context object representing the environment creation process.

### Response
No return value.
```

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

### Install _() globally with gettext.install

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

Install the _() function into the built-in namespace for an application. This example uses the default locale directory and is typically placed in the main driver file.

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

```

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

### Distribution version attribute example

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

Shows how to get the version number from a Distribution instance using the version attribute. The example shows the version for the 'wheel' distribution.

```python
>>> dist.version
'0.32.3'
```

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

### Run example.py directly (no output)

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

Command to run the example module directly. The output is empty, indicating all doctests passed.

```bash
$ python example.py
$

```

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

### Pack a directory into an archive and run it

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

Use the command line to create an archive from a directory and then execute it. The output from the application is displayed.

```bash
$ python -m zipapp myapp
$ python myapp.pyz
<output from myapp>
```

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

### Command to run the demo server

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

Command-line invocation to run the ExampleService demo server using the xmlrpc.server module.

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

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

### bar.pth contents

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

Example .pth file named bar.pth. Blank lines and lines starting with # are skipped. Lines starting with import are executed. Non-existing items are not added to sys.path.

```plaintext
# bar package configuration

bar

```

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

### test.support.import_helper.modules_setup

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

Returns a copy of sys.modules.

```APIDOC
## modules_setup()

### Description
Return a copy of `sys.modules`.

### Returns
dict - A copy of the sys.modules dictionary.
```

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

### foo.pth contents

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

Example .pth file named foo.pth. Blank lines and lines starting with # are skipped. Lines starting with import are executed. Non-existing items are not added to sys.path.

```plaintext
# foo package configuration

foo
bar
bletch

```

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

### Perform a GET request with http.client.HTTPSConnection

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

Example from the request() documentation showing how to send a GET request to https://docs.python.org/3/ and print the response status and reason. The output is '200 OK'.

```python
>>> import http.client
>>> host = "docs.python.org"
>>> conn = http.client.HTTPSConnection(host)
>>> conn.request("GET", "/3/", headers={"Host": host})
>>> response = conn.getresponse()
>>> print(response.status, response.reason)
200 OK

```

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

### Cursor connection attribute example

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

Shows that a Cursor's connection attribute refers to the Connection that created it. The example creates an in-memory database, gets a cursor, and checks equality.

```python
>>> con = sqlite3.connect(":memory:")
>>> cur = con.cursor()
>>> cur.connection == con
True
>>> con.close()
```

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

### Start HTTP server and open browser

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

Start the server and additionally open a web browser to a module index page. Each served page has a navigation bar for help, search, module index, topics, and keywords.

```shell
python -m pydoc -b
```

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

### AsyncMock.await_args_list example

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

Shows how await_args_list accumulates all awaits in sequence, starting as an empty list.

```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')]
```

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

### store action: command line example

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

Example command line that the parser would process for the store action options.

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

```

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

### IsolatedAsyncioTestCase example showing event order

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

Example from the unittest documentation illustrating the order of setup, test, and cleanup events in an IsolatedAsyncioTestCase. After running, events contains ["setUp", "asyncSetUp", "test_response", "asyncTearDown", "tearDown", "cleanup"].

```python
from unittest import IsolatedAsyncioTestCase

events = []


class Test(IsolatedAsyncioTestCase):


    def setUp(self):
        events.append("setUp")

    async def asyncSetUp(self):
        self._async_connection = await AsyncConnection()
        events.append("asyncSetUp")

    async def test_response(self):
        events.append("test_response")
        response = await self._async_connection.get("https://example.com")
        self.assertEqual(response.status_code, 200)
        self.addAsyncCleanup(self.on_cleanup)

    def tearDown(self):
        events.append("tearDown")

    async def asyncTearDown(self):
        await self._async_connection.close()
        events.append("asyncTearDown")

    async def on_cleanup(self):
        events.append("cleanup")

if __name__ == "__main__":
    unittest.main()
```

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

### Pattern.search() with pos parameter

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

Searches for a match starting at a given position. The example shows that 'd' matches at index 0 in 'dog', but when pos=1, no match is found because the search starts after the 'd'.

```python
>>> pattern = re.compile("d")
>>> pattern.search("dog")     # Match at index 0
<re.Match object; span=(0, 1), match='d'>
>>> pattern.search("dog", 1)  # No match; search doesn't include the "d"

```

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

### Read and explore a configuration file

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

Reads back 'example.ini' and demonstrates section listing, membership tests, key access, iteration (keys are case-insensitive and stored lowercase), and DEFAULT section fallback.

```python
>>> config = configparser.ConfigParser()
>>> config.sections()
[]
>>> config.read('example.ini')
['example.ini']
>>> config.sections()
['forge.example', 'topsecret.server.example']
>>> 'forge.example' in config
True
>>> 'python.org' in config
False
>>> config['forge.example']['User']
'hg'
>>> config['DEFAULT']['Compression']
'yes'
>>> topsecret = config['topsecret.server.example']
>>> topsecret['ForwardX11']
'no'
>>> topsecret['Port']
'50022'
>>> for key in config['forge.example']:
...     print(key)
user
compressionlevel
serveraliveinterval
compression
forwardx11
>>> config['forge.example']['ForwardX11']
'yes'
```

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

### os.startfile(_path_[, _operation_][, _arguments_][, _cwd_][, _show_cmd_])

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

Starts a file with its associated application on Windows. Acts like double-clicking the file or using the 'start' command. Supports command verbs like 'open', 'print', 'edit', 'explore', and 'find'.

```APIDOC
## os.startfile(_path_[, _operation_][, _arguments_][, _cwd_][, _show_cmd_])

### Description
Start a file with its associated application. When _operation_ is not specified, acts like double-clicking the file in Windows Explorer. When another _operation_ is given, it must be a "command verb" specifying what to do with the file.

### Parameters
- **path** (str) - Required - The path to the file or directory to start.
- **operation** (str) - Optional - A command verb such as 'open', 'print', 'edit', 'explore', or 'find'.
- **arguments** (str) - Optional - Arguments to be passed to the application as a single string.
- **cwd** (str) - Optional - Absolute path to set as the working directory. Relative paths are resolved against this.
- **show_cmd** (int) - Optional - Integer value to override the default window style, as supported by Win32 ShellExecute().

### Return Value
Returns as soon as the associated application is launched. No way to wait for the application to close or retrieve exit status.

### Exceptions
- **NotImplementedError** - Raised if the Win32 ShellExecute() function cannot be resolved.

### Audit Events
- `os.startfile` with arguments `path`, `operation`.
- `os.startfile/2` with arguments `path`, `operation`, `arguments`, `cwd`, `show_cmd`.

### Availability
Windows.

### Notes
- The _path_ parameter is relative to the current directory or _cwd_. Use pathlib or os.path.normpath() to ensure proper encoding.
- Changed in version 3.10: Added _arguments_, _cwd_, _show_cmd_ arguments and the `os.startfile/2` audit event.
```

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

### Equivalent discover commands with options

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

Two equivalent ways to specify the start directory and pattern for test discovery. The first uses explicit options, the second uses positional arguments.

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

```shell
python -m unittest discover project_directory "*_test.py"
```

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

### sys.__unraisablehook__

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

An attribute that contains the original value of unraisablehook at the start of the program, allowing restoration if it gets replaced.

```APIDOC
## sys.__unraisablehook__

### Description
This object contains the original value of `unraisablehook` at the start of the program. It is saved so that `unraisablehook` can be restored in case it happens to get replaced with a broken or alternative object.

### Notes
- Added in version 3.8.
```

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

### sys.__excepthook__

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

An attribute that contains the original value of excepthook at the start of the program, allowing restoration if it gets replaced.

```APIDOC
## sys.__excepthook__

### Description
This object contains the original value of `excepthook` at the start of the program. It is saved so that `excepthook` can be restored in case it happens to get replaced with a broken or alternative object.
```

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

### sys.__displayhook__

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

An attribute that contains the original value of displayhook at the start of the program, allowing restoration if it gets replaced.

```APIDOC
## sys.__displayhook__

### Description
This object contains the original value of `displayhook` at the start of the program. It is saved so that `displayhook` can be restored in case it happens to get replaced with a broken or alternative object.
```

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

### sys.__breakpointhook__

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

An attribute that contains the original value of breakpointhook at the start of the program, allowing restoration if it gets replaced.

```APIDOC
## sys.__breakpointhook__

### Description
This object contains the original value of `breakpointhook` at the start of the program. It is saved so that `breakpointhook` can be restored in case it happens to get replaced with a broken or alternative object.

### Attribute
`sys.__breakpointhook__`

### Notes
- Added in version 3.7.
```

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

### BasicInterpolation configuration example

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

Shows a configuration file using BasicInterpolation syntax with %(name)s references. Values are resolved on demand, so referenced keys can appear in any order. Use %% to escape a literal percent sign.

```ini
[Paths]
home_dir: /Users
my_dir: %(home_dir)s/lumberjack
my_pictures: %(my_dir)s/Pictures

[Escape]
# use a %% to escape the % sign (% is the only character that needs to be escaped):
gain: 80%%
```

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

### BaseRequestHandler.setup()

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

Called before the handle() method to perform initialization actions. Default implementation does nothing.

```APIDOC
## BaseRequestHandler.setup()

### Description
Called before the `handle()` method to perform any initialization actions required. The default implementation does nothing.

### Method
setup()

### Parameters
None

### Returns
None

### Notes
Can be overridden in subclasses.
```

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

### Query all entry points

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

Calls entry_points() to get an EntryPoints object containing all installed entry points.

```python
>>> eps = entry_points()

```
Tokens:
Raw