Python Standard Library

https://docs.python.org/3/library/
Admin
The Python Standard Library is a collection of modules providing built-in functionality for file...
Tokens:3,893,313
Snippets:24,394
Trust Score:10
Update:11 hours ago
Show doc for...
Tokens:
Raw
### ExtendedEnvBuilder example with custom install scripts

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

This snippet shows a complete example of extending EnvBuilder to customize virtual environment creation. It overrides install_scripts to install setuptools and pip from bootstrap URLs, and provides a main() function with command-line arguments for creating environments. The script is available for download online.

```python
        :param context: The information for the virtual environment
                        creation request being processed.
        """
        url = "https://bootstrap.pypa.io/ez_setup.py"
        self.install_script(context, 'setuptools', url)
        # clear up the setuptools archive which gets downloaded
        pred = lambda o: o.startswith('setuptools-') and o.endswith('.tar.gz')
        files = filter(pred, os.listdir(context.bin_path))
        for f in files:
            f = os.path.join(context.bin_path, f)
            os.unlink(f)

    def install_pip(self, context):
        """
        Install pip in the virtual environment.

        :param context: The information for the virtual environment
                        creation request being processed.
        """
        url = 'https://bootstrap.pypa.io/get-pip.py'
        self.install_script(context, 'pip', url)


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

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

### Example usage of Process methods (start, is_alive, terminate, exitcode)

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

Interactive Python session showing how to create a Process with the 'spawn' context, start it, check is_alive, terminate it, and verify the exitcode equals -signal.SIGTERM. Note that start, join, is_alive, terminate, and exitcode should only be called by the process that created the process object.

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

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

### turtle.towards() - get angle to a point

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

Returns the angle from the turtle's position to a given point, measured from the start orientation. The example moves to (10,10) and gets the angle to (0,0).

```python
>>> turtle.goto(10, 10)
>>> turtle.towards(0,0)
225.0
```

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

### Typical use of site.StartupState

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

Shows the recommended pattern for batching .pth and .start file processing across multiple site directories. Create a StartupState, call addsitedir() for each directory, then call process() to apply the accumulated state. process() must not be called more than once on the same instance.

```python
state = site.StartupState()
for sitedir in site_dirs:
    state.addsitedir(sitedir)
state.process()
```

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

### Get a Distribution instance with distribution()

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

Shows how to obtain a Distribution object for an installed package using importlib.metadata.distribution(). The example uses 'wheel' and prints the type of the returned instance.

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

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

### foo.start startup file

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

Example contents of a foo.start file that imports the foo.submod module and calls its initialize() function before user code runs.

```plaintext
# foo package startup code

foo.submod:initialize

```

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

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

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

Returns a list of PackagePath objects for the named distribution. Raises PackageNotFoundError if not installed, or returns None if the RECORD/SOURCES.txt metadata is missing. The example shows accessing the size, dist, and hash properties of a PackagePath.

```python
>>> util = [p for p in files('wheel') if 'util.py' in str(p)][0]
>>> util
PackagePath('wheel/util.py')
>>> util.size
859
>>> util.dist
<importlib.metadata._hooks.PathDistribution object at 0x101e0cef0>
>>> util.hash
<FileHash mode: sha256 value: bYkw5oMccfazVCoYQwKkkemoVyMAFoR34mmKBx8R1NI>
```

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

### TestCase with setUp method

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

Shows how to factor out repetitive set-up code by implementing setUp(), which is called automatically before each test. Includes two test methods that use the widget created in setUp.

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

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

### GET request example

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

Demonstrates making a GET request using http.client.HTTPSConnection and reading the response.

```APIDOC
## GET request example

### Description
Demonstrates making a GET request using http.client.HTTPSConnection and reading the response.

### Method
GET

### Endpoint
https://www.python.org/

### Parameters
#### Query Parameters
None

#### Request Body
None

### Request Example
```python
import http.client
conn = http.client.HTTPSConnection("www.python.org")
conn.request("GET", "/")
r1 = conn.getresponse()
print(r1.status, r1.reason)
data1 = r1.read()
```

### Response
#### Success Response (200)
- **status** (int) - HTTP status code
- **reason** (str) - Reason phrase
- **data** (bytes) - Response body

#### Response Example
```
200 OK
b'<!doctype html>...'
```
```

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

### Run example.py from command line

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

Command to run the example module directly. No output indicates all doctests passed.

```shell
$ python example.py
$
```

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

### Example command line: --file=outfile -q

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

A sample command line that users can run with the script. It demonstrates the conventional syntax for specifying options with values and flags.

```bash
<yourscript> --file=outfile -q
```

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

### GET Request with Parameters

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

Example session using the GET method to retrieve a URL containing parameters.

```APIDOC
## GET Request with Parameters

### Description
Demonstrates how to perform a GET request with query parameters using urllib.parse.urlencode and urllib.request.urlopen.

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

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

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

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

Launches a file with its associated application on Windows. Supports optional operation, arguments, working directory, and window style parameters.

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

### Description
Launches a file with its associated application on Windows. The operation is a command verb such as 'open', 'print', 'edit', 'explore', or 'find'. Returns as soon as the application is launched; there is no way to wait for the application to close or retrieve its exit status.

### Method
Function call

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

### Parameters
- **path** (str) - Required - The path to the file to launch. Relative to current directory or cwd. For absolute paths, ensure the first character is not a slash ('/').
- **operation** (str) - Optional - A command verb specifying what to do with the file. Common verbs: 'open', 'print', 'edit', 'explore', 'find'.
- **arguments** (str) - Optional - Arguments to pass to the application when launching. May have no effect when launching a document.
- **cwd** (str) - Optional - Absolute path to override the default working directory. Relative paths are resolved against this argument.
- **show_cmd** (int) - Optional - Overrides the default window style. Values are integers supported by the Win32 ShellExecute() function.

### Return Value
None. Returns as soon as the associated application is launched.

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

### Auditing Events
- `os.startfile` with arguments `path`, `operation`
- `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.
- Use pathlib or os.path.normpath() to ensure paths are properly encoded for Win32.
```

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

### Multiple patches in setUp and tearDown

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

Typical use case for patching multiple objects in setUp and stopping them in tearDown. The patchers are started in setUp and stopped 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()
```

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

### EnvBuilder.setup_scripts(context)

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

Installs activation scripts appropriate to the platform into the virtual environment. This method is called during environment creation.

```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 returned by the `create` method.

### Response
No return value.
```

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

### Iterate over all keys in a GDBM database using firstkey() and nextkey()

Source: https://docs.python.org/3/library/dbm.html

This example prints every key in the database 'db' without creating a list in memory. It uses the firstkey() method to get the starting key and nextkey() to traverse the database in GDBM's internal hash order, which is not sorted by key values.

```python
k = db.firstkey()
while k is not None:
    print(k)
    k = db.nextkey(k)
```

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

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

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

Calls version('wheel') to return the installed distribution package version as a string. Raises PackageNotFoundError if the package is not installed.

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

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

### await start_server()

Source: https://docs.python.org/3/library/asyncio-api-index.html

Start a TCP server.

```APIDOC
## await start_server()

### Description
Start a TCP server.

### Method
await

### Usage
Use to start a TCP server.

### Examples
- See also the [streams APIs](https://docs.python.org/3/library/asyncio-stream.html#asyncio-streams) documentation.
```

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

### Equivalent dict.update() iteration order example

Source: https://docs.python.org/3/library/collections.html

Shows that the same ordering as the ChainMap example is obtained by starting with the last mapping and applying a series of dict.update() calls. The example copies the baseline dict, updates it with adjustments, and lists the keys.

```python
>>> combined = baseline.copy()
>>> combined.update(adjustments)
>>> list(combined)
['music', 'art', 'opera']
```

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

### Run example.py with -v flag

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

Command to run the example module with verbose output, showing detailed log of each test and a summary at the end.

```shell
$ python example.py -v
Trying:
    factorial(5)
Expecting:
    120
ok
Trying:
    [factorial(n) for n in range(6)]
Expecting:
    [1, 1, 2, 6, 24, 120]
ok
```

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

### EnvBuilder.post_setup(context)

Source: https://docs.python.org/3/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 returned by the `create` method.

### Response
No return value.
```

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

### Command-line timing with setup statement

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

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

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

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

### Get the TurtleScreen with getscreen()

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

Returns the TurtleScreen object the turtle is drawing on, allowing TurtleScreen methods to be called. The example shows getting the screen and changing its background color.

```python
>>> ts = turtle.getscreen()
>>> ts
<turtle._Screen object at 0x...>
>>> ts.bgcolor("pink")
```

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

### Passing setup with import statement

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

Define a function and pass an import statement in the setup parameter to make it accessible to timeit. The example prints the timing of test() 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"))
```

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

### Open file with Path.open and read a line

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

Opens a file like the built-in open() and reads the first line. The example prints the first line of 'setup.py'.

```python
>>> p = Path('setup.py')
>>> with p.open() as f:
...     f.readline()
...
'#!/usr/bin/env python3\n'
```

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

### Command-line invocation for demo server

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

Runs the ExampleService demo server from the command line using python -m xmlrpc.server.

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

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

### linecache.getline example

Source: https://docs.python.org/3/library/linecache.html

Shows how to use linecache.getline to retrieve a specific line from a file. The example imports linecache and gets line 8 from linecache.__file__, returning the line with its newline character.

```python
>>> import linecache
>>> linecache.getline(linecache.__file__, 8)
'import sys\n'
```

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

### Get HTTP headers

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

Example of querying HTTP headers of a URL using asyncio.open_connection().

```APIDOC
## Get HTTP headers

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

### Usage
```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))
```

### Command Line Usage
```
python example.py http://example.com/path/page.html
```
or with HTTPS:
```
python example.py https://example.com/path/page.html
```
```

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

### test.support.import_helper.modules_setup

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

Returns a copy of sys.modules.

```APIDOC
## test.support.import_helper.modules_setup

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

### Method
N/A (Python function)

### Parameters
None.

### Returns
- A copy of `sys.modules` (dict).

### Usage Example
```python
oldmodules = modules_setup()
```

### Notes
- This is typically used to save the current module state before tests.
```

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

### Equivalent command lines for the example

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

Four alternative command lines that are all equivalent to the example above, showing how optparse supports long and short options, merged short options, and various ways to associate options with arguments.

```bash
<yourscript> -f outfile --quiet
<yourscript> --quiet --file outfile
<yourscript> -q -foutfile
<yourscript> -qfoutfile
```

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

### Get window width with window_width()

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

Returns the width of the turtle window. In this example, it returns 640.

```python
>>> screen.window_width()
640
```

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

### Get window height with window_height()

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

Returns the height of the turtle window. In this example, it returns 480.

```python
>>> screen.window_height()
480
```

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

### Cmd.cmdloop(intro=None)

Source: https://docs.python.org/3/library/cmd.html

Repeatedly issue a prompt, accept input, parse an initial prefix off the received input, and dispatch to action methods, passing them the remainder of the line as argument. The optional argument is a banner or intro string to be issued before the first prompt.

```APIDOC
## Cmd.cmdloop(intro=None)

### Description
Repeatedly issue a prompt, accept input, parse an initial prefix off the received input, and dispatch to action methods, passing them the remainder of the line as argument. The optional argument is a banner or intro string to be issued before the first prompt (this overrides the intro class attribute). If the readline module is loaded, input will automatically inherit bash-like history-list editing. An end-of-file on input is passed back as the string 'EOF'. An interpreter instance will recognize a command name foo if and only if it has a method do_foo(). As a special case, a line beginning with the character '?' is dispatched to the method do_help(). As another special case, a line beginning with the character '!' is dispatched to the method do_shell() (if such a method is defined). This method will return when the postcmd() method returns a true value. If completion is enabled, completing commands will be done automatically, and completing of commands args is done by calling complete_foo() with arguments text, line, begidx, and endidx.

### Method
cmdloop

### Parameters
#### Optional Arguments
- **intro** (string) - Optional - A banner or intro string to be issued before the first prompt.

### Return Value
Returns when the postcmd() method returns a true value.
```

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

### MULTILINE mode: prefixmatch() vs search() with '^'

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

In MULTILINE mode, prefixmatch() only matches at the start of the string, while search() with '^' matches at the start of each line. The example shows a match at line 3.

```python
>>> re.prefixmatch("X", "A\nB\nX", re.MULTILINE)  # No match
>>> re.search("^X", "A\nB\nX", re.MULTILINE)  # Match
<re.Match object; span=(4, 5), match='X'>
```

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

### Simple format string examples

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

Examples showing how to reference positional and keyword arguments, attributes, and elements in format strings.

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

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

### Expanded example showing process IDs

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

Extends the basic example to print module name, parent process ID, and process ID for both the main process and the child process. Demonstrates the info() helper and the use of os.getppid() and os.getpid().

```python
from multiprocessing import Process
import os

def info(title):
    print(title)
    print('module name:', __name__)
    print('parent process:', os.getppid())
    print('process id:', os.getpid())

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

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

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

### timeit.Timer with gc.enable() in setup

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

Example showing how to re-enable garbage collection during timing by passing 'gc.enable()' as the setup statement to timeit.Timer. This is useful when GC is an important component of the measured function's performance.

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

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

### asyncio.Server.start_serving()

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

Starts accepting connections. This method is idempotent, so it can be called when the server is already serving. It is useful for servers created with start_serving=False.

```APIDOC
## start_serving()

### Description
Start accepting connections. This method is idempotent, so it can be called when the server is already serving. The `start_serving` keyword-only parameter to `loop.create_server()` and `asyncio.start_server()` allows creating a Server object that is not accepting connections initially. In this case `Server.start_serving()`, or `Server.serve_forever()` can be used to make the Server start accepting connections.

### Method
start_serving()

### Parameters
None

### Returns
None
```

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

### Unsafe main module example causing RuntimeError

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

This example fails with a RuntimeError when using the spawn or forkserver start method because the main module is not protected. It creates a Process without an entry point guard.

```python
from multiprocessing import Process

def foo():
    print('hello')

p = Process(target=foo)
p.start()
```

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

### setUpClass and tearDownClass as class methods

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

Shows how to implement setUpClass and tearDownClass as class methods. The setUpClass method creates an expensive connection object, and tearDownClass destroys it. These methods must be decorated with @classmethod.

```python
import unittest

class Test(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls._connection = createExpensiveConnectionObject()

    @classmethod
    def tearDownClass(cls):
        cls._connection.destroy()
```

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

### Manage patches with start and stop in setUp and tearDown

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

Use patch.start() in setUp and patch.stop() in tearDown to control patch lifetime. The mock is stored as an attribute for assertions. Ensure stop is called to undo the patch.

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

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

### GET method example session

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

Shows a complete session using the GET method, including reading the entire response and reading in chunks. Also demonstrates an invalid request that returns a 404 status.

```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: Using sched.scheduler with enter() and enterabs()

Source: https://docs.python.org/3/library/sched.html

Shows how to create a scheduler, define callback functions, and schedule events with relative (enter) and absolute (enterabs) times. The example output demonstrates that events with the same priority run in the order they were entered, and that 'keyword' runs after 'positional' despite having higher priority because enter() is relative.

```python
>>> import sched, time
>>> s = sched.scheduler(time.time, time.sleep)
>>> def print_time(a='default'):
...     print("From print_time", time.time(), a)
...
>>> def print_some_times():
...     print(time.time())
...     s.enter(10, 1, print_time)
...     s.enter(5, 2, print_time, argument=('positional',))
...     # despite having higher priority, 'keyword' runs after 'positional' as enter() is relative
...     s.enter(5, 1, print_time, kwargs={'a': 'keyword'})
...     s.enterabs(1_650_000_000, 10, print_time, argument=("first enterabs",))
...     s.enterabs(1_650_000_000, 5, print_time, argument=("second enterabs",))
...     s.run()
...     print(time.time())
...
>>> print_some_times()
1652342830.3640375
From print_time 1652342830.3642538 second enterabs
From print_time 1652342830.3643398 first enterabs
From print_time 1652342835.3694863 positional
From print_time 1652342835.3696074 keyword
From print_time 1652342840.369612 default
1652342840.3697174
```

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

### Simple hashing with blake2b

Source: https://docs.python.org/3/library/hashlib.html

Example of constructing a hash object, updating it with data, and getting the hex digest.

```APIDOC
## Simple hashing with blake2b

### Description
To calculate hash of some data, you should first construct a hash object by calling the appropriate constructor function (blake2b() or blake2s()), then update it with the data by calling update() on the object, and, finally, get the digest out of the object by calling digest() (or hexdigest() for hex-encoded string).

### Example
```python
>>> from hashlib import blake2b
>>> h = blake2b()
>>> h.update(b'Hello world')
>>> h.hexdigest()
'6ff843ba685842aa82031d3f53c48b66326df7639a63d128974c5c14f31a0f33343a8c65551134ed1ae0f2b0dd2bb495dc81039e3eeb0aa1bb0388bbeac29183'
```

### Shortcut Example
```python
>>> from hashlib import blake2b
>>> blake2b(b'Hello world').hexdigest()
'6ff843ba685842aa82031d3f53c48b66326df7639a63d128974c5c14f31a0f33343a8c65551134ed1ae0f2b0dd2bb495dc81039e3eeb0aa1bb0388bbeac29183'
```

### Iterative Update Example
```python
>>> from hashlib import blake2b
>>> items = [b'Hello', b' ', b'world']
>>> h = blake2b()
>>> for item in items:
...     h.update(item)
...
>>> h.hexdigest()
'6ff843ba685842aa82031d3f53c48b66326df7639a63d128974c5c14f31a0f33343a8c65551134ed1ae0f2b0dd2bb495dc81039e3eeb0aa1bb0388bbeac29183'
```

```
Tokens:
Raw