Python Standard Library

https://docs.python.org/3.12/library/
Admin
The Python Standard Library is a comprehensive collection of built-in modules and packages...
Tokens:3,670,630
Snippets:23,728
Trust Score:10
Update:1 day ago
Show doc for...
Tokens:
Raw
### TestCase with setUp for common setup

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

Factors out repetitive setup code by implementing setUp(), which the framework calls automatically for every test. The example 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')
```

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

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

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

A typical use case for patching multiple objects in a TestCase's setUp and tearDown methods. 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()
```

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

### Create virtual environment and install wheel

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

Commands to set up a virtual environment and install the 'wheel' package using pip, as a prerequisite for the importlib.metadata examples.

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

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

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

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

Demonstrates creating a process with the 'spawn' context, starting it, terminating it, and checking its exit code. The output shows the process states and exit code after termination.

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

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

### Discover with namespace package start directory

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

For namespace packages, specify the start directory as a dotted package name and the top-level directory explicitly. The example shows a directory structure and the command.

```shell
# proj/  <-- current directory
#   namespace/
#     mypkg/
#       __init__.py
#       test_mypkg.py

python -m unittest discover -s namespace.mypkg -t .
```

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

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

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

Use patch.start() in setUp and patch.stop() in tearDown to control patch lifecycle. The mock is stored as an instance attribute for use in tests. 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()
```

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

### turtle.towards() - Get angle towards a point

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

Returns the angle between the line from the turtle's position to the specified point and the turtle's start orientation. The example moves the turtle to (10,10) and then gets the angle towards (0,0).

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

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

### setup()

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

Sets the size and position of the main window.

```APIDOC
## setup()

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

### Method
setup()

### Parameters
- *width* - Optional - Integer or float, the width of the window.
- *height* - Optional - Integer or float, the height of the window.
- *startx* - Optional - Integer or float, the x-coordinate of the window's left edge.
- *starty* - Optional - Integer or float, the y-coordinate of the window's top edge.
```

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

### Get a Distribution instance for a package

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

Call importlib.metadata.distribution() to get a Distribution object for an installed package. Raises PackageNotFoundError if the package is not installed.

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

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

### turtle.setup() window size and position examples

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

Shows two calls to screen.setup() with different argument types: integers for pixel sizes and floats for screen fractions, with startx/starty controlling position. The first sets a 200x200 pixel window at the upper left; the second sets the window to 75% of screen width by 50% of screen height and centers it.

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

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

### Path.open example

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

Opens the file pointed to by the path, similar to built-in open(). The example reads the first line of 'setup.py'.

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

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

### GET Request Example

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

Example session using the GET method with http.client.HTTPSConnection, including reading the entire content and reading in chunks.

```APIDOC
## GET Request Example

### Description
Example session using the GET method with http.client.HTTPSConnection, including reading the entire content and reading in chunks.

### Method
GET

### Endpoint
/

### Parameters
#### Path Parameters
None

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

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

#### Response Example
```python
200 OK
b'<!doctype html>\n<!--[if"...'
```

#### Error Response (404)
- **status** (int) - HTTP status code.
- **reason** (str) - HTTP reason phrase.

#### Response Example
```python
404 Not Found
```
```

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

### Run example.py from command line

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

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

```bash
$ python example.py
$
```

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

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

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

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

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

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

### turtle.setup(width=_CFG['width'], height=_CFG['height'], startx=_CFG['leftright'], starty=_CFG['topbottom'])

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

Sets 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=_CFG['width'], height=_CFG['height'], startx=_CFG['leftright'], starty=_CFG['topbottom'])

### 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
setup()

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

### Returns
None

```

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

### GET request example with http.client

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

Shows a session using the GET method. It creates an HTTPSConnection to www.python.org, sends a GET request, reads the response, and demonstrates reading data in chunks. Also includes an example of 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()
```

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

### Instantiate Path with 'setup.py'

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

Shows creating a Path object for 'setup.py', which returns a PosixPath on POSIX systems.

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

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

### EnvBuilder.post_setup(context)

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

Performs any post-setup steps after the environment is created. This method is a hook that can be overridden.

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

### Description
Performs any post-setup steps after the environment is created. This method is part of the creation process and can be overridden in subclasses.

### Method
`post_setup(context)`

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

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

### multiprocessing.Process Example Usage

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

Example usage of some of the methods of Process, demonstrating start, is_alive, terminate, and exitcode.

```APIDOC
## multiprocessing.Process Example Usage

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

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

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

### Pattern.match() with pos parameter

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

Matches at the beginning of the string, optionally starting at a given position. The example shows that 'o' does not match at the start of 'dog' but matches when starting at index 1.

```python
>>> pattern = re.compile("o")
>>> pattern.match("dog")      # No match as "o" is not at the start of "dog".
>>> pattern.match("dog", 1)   # Match as "o" is the 2nd character of "dog".
<re.Match object; span=(1, 2), match='o'>
```

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

### EnvBuilder.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
## EnvBuilder.setup_scripts(context)

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

### Method
setup_scripts

### Parameters
- **context** (EnvBuilder context object) - Required - The context object containing environment paths and attributes.

### Returns
None
```

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

### modules_setup()

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

Returns a copy of sys.modules.

```APIDOC
## modules_setup()

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

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

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

### Using multiprocessing.Pool with apply_async, map, imap, and timeout

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

Example from the multiprocessing.Pool section showing how to start a pool of 4 worker processes, evaluate a function asynchronously with apply_async, map over a range, use imap for lazy iteration, and observe that get(timeout=1) raises multiprocessing.TimeoutError when the function takes longer than the timeout.

```python
from multiprocessing import Pool
import time

def f(x):
    return x*x

if __name__ == '__main__':
    with Pool(processes=4) as pool:         # start 4 worker processes
        result = pool.apply_async(f, (10,)) # evaluate "f(10)" asynchronously in a single process
        print(result.get(timeout=1))        # prints "100" unless your computer is *very* slow

        print(pool.map(f, range(10)))       # prints "[0, 1, 4,..., 81]"

        it = pool.imap(f, range(10))
        print(next(it))                     # prints "0"
        print(next(it))                     # prints "1"
        print(it.next(timeout=1))           # prints "4" unless your computer is *very* slow

        result = pool.apply_async(time.sleep, (10,))
        print(result.get(timeout=1))        # raises multiprocessing.TimeoutError
```

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

### Get version of installed distribution

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

Use importlib.metadata.version() to retrieve the version string of an installed distribution package, e.g., 'wheel'.

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

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

### Basic example: create and run an executable archive

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

Shows how to use the command-line interface to create an executable archive from a directory containing Python code. When run, the archive executes the main function from the module myapp.

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

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

### Indentation in doctest examples is ignored

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

The starting column of a doctest example does not matter. Leading whitespace is stripped from expected output based on the initial '>>> ' line.

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

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

### Pattern.search() with pos parameter

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

Searches for a match starting at a given position. The example shows that searching 'dog' with pos=1 does not find the 'd' because the search starts after it.

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

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

### EnvBuilder.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
## 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** (EnvBuilder context object) - Required - The context object containing environment paths and attributes.

### Returns
None
```

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

### Cmd.cmdloop(intro=None)

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

Repeatedly issue a prompt, accept input, parse an initial prefix, and dispatch to action methods. The optional intro argument overrides the intro class attribute.

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

### Method
cmdloop

### Parameters
- **intro** (optional) - Banner or intro string to be issued before the first prompt.

### Behavior
- If the readline module is loaded, input inherits bash-like history-list editing.
- An end-of-file on input is passed back as the string 'EOF'.
- A line beginning with '?' is dispatched to do_help().
- A line beginning with '!' is dispatched to do_shell() (if defined).
- Returns when postcmd() returns a true value.
- If completion is enabled, completing commands is automatic; command args completion is done by calling complete_foo() with arguments text, line, begidx, and endidx.
```

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

### JSONEncoder.encode() example

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

Shows how to use json.JSONEncoder().encode() to get a JSON string representation of a Python data structure. The example encodes a dictionary with a list value.

```python
>>> json.JSONEncoder().encode({"foo": ["bar", "baz"]})
'{"foo": ["bar", "baz"]}'
```

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

### Run example.py with -v flag (verbose output)

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

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

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

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

### date.isocalendar() example

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

Demonstrates the isocalendar() method returning a named tuple with year, week, and weekday. The example shows dates around the start of ISO year 2004.

```python
>>> from datetime import date
>>> date(2003, 12, 29).isocalendar()
datetime.IsoCalendarDate(year=2004, week=1, weekday=1)
>>> date(2004, 1, 4).isocalendar()
datetime.IsoCalendarDate(year=2004, week=1, weekday=7)
```

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

### curses.setupterm(term=None, fd=-1)

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

Initializes the terminal with the given terminal name and file descriptor.

```APIDOC
## curses.setupterm(term=None, fd=-1)

### Description
Initialize the terminal. term is a string giving the terminal name, or None; if omitted or None, the value of the TERM environment variable will be used. fd is the file descriptor to which any initialization sequences will be sent; if not supplied or -1, the file descriptor for sys.stdout will be used.

### Method
Function call

### Signature
curses.setupterm(term=None, fd=-1)

### Parameters
- **term** (str or None) - Optional - The terminal name. If None, the TERM environment variable is used.
- **fd** (int) - Optional - The file descriptor to send initialization sequences to. If -1, sys.stdout's file descriptor is used.

### Returns
None

### Example
```python
import curses
curses.setupterm()
```
```

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

### Get the TurtleScreen with getscreen()

Source: https://docs.python.org/3.12/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")
```

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

### Setting up a meta path finder and path entry finder

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

Registers a meta path finder on sys.meta_path and a path entry finder on sys.path_hooks. The example uses illustrative classes SpamMetaPathFinder and SpamPathEntryFinder, and loader_details for source files. Ensure correct priority placement in the lists.

```python
import importlib.machinery
import sys

# For illustrative purposes only.
SpamMetaPathFinder = importlib.machinery.PathFinder
SpamPathEntryFinder = importlib.machinery.FileFinder
loader_details = (importlib.machinery.SourceFileLoader,
                  importlib.machinery.SOURCE_SUFFIXES)

# Setting up a meta path finder.
# Make sure to put the finder in the proper location in the list in terms of
# priority.
sys.meta_path.append(SpamMetaPathFinder)

# Setting up a path entry finder.
# Make sure to put the path hook in the proper location in the list in terms
# of priority.
sys.path_hooks.append(SpamPathEntryFinder.path_hook(loader_details))
```

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

### ThreadingMixIn TCP server example

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

Complete example of a threaded TCP server using ThreadingMixIn. It starts a server thread, handles multiple clients concurrently, and shuts down after processing.

```python
import socket
import threading
import socketserver

class ThreadedTCPRequestHandler(socketserver.BaseRequestHandler):

    def handle(self):
        data = str(self.request.recv(1024), 'ascii')
        cur_thread = threading.current_thread()
        response = bytes("{}: {}".format(cur_thread.name, data), 'ascii')
        self.request.sendall(response)

class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
    pass

def client(ip, port, message):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
        sock.connect((ip, port))
        sock.sendall(bytes(message, 'ascii'))
        response = str(sock.recv(1024), 'ascii')
        print("Received: {}".format(response))

if __name__ == "__main__":
    # Port 0 means to select an arbitrary unused port
    HOST, PORT = "localhost", 0

    server = ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler)
    with server:
        ip, port = server.server_address

        # Start a thread with the server -- that thread will then start one
        # more thread for each request
        server_thread = threading.Thread(target=server.serve_forever)
        # Exit the server thread when the main thread terminates
        server_thread.daemon = True
        server_thread.start()
        print("Server loop running in thread:", server_thread.name)

        client(ip, port, "Hello World 1")
        client(ip, port, "Hello World 2")
        client(ip, port, "Hello World 3")

        server.shutdown()
```

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

### Example output of --version

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

Shows the output when running a script with --version. The %prog placeholder is replaced with the program name (e.g., foo).

```bash
$ /usr/bin/foo --version
foo 1.0
```

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

### date.isoformat() example

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

Shows how to get an ISO 8601 formatted string (YYYY-MM-DD) from a date object.

```python
>>> from datetime import date
>>> date(2002, 12, 4).isoformat()
'2002-12-04'
```

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

### Set and get background image with screen.bgpic()

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

Sets or returns the background image of the TurtleScreen. Pass a gif filename to set the image, "nopic" to delete it, or None to get the current image name. The example shows getting 'nopic', setting 'landscape.gif', and retrieving it.

```python
>>> screen.bgpic()
'nopic'
>>> screen.bgpic("landscape.gif")
>>> screen.bgpic()
"landscape.gif"
```

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

### Using asyncio.Server.serve_forever() with start_server()

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

This example demonstrates starting a server with asyncio.start_server() and then running it indefinitely with serve_forever(). The server will keep accepting connections until the serve_forever task is cancelled, which also closes the server.

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

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

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

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

### EnvBuilder.setup_scripts(context)

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

Sets up the activation scripts and other scripts in the virtual environment. This method is a hook that can be overridden.

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

### Description
Sets up the scripts (e.g., activation scripts) in the virtual environment. This method is part of the creation process and can be overridden in subclasses.

### Method
`setup_scripts(context)`

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

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

### turtle.fillcolor() usage examples

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

Shows how to get and set the fill color using a color string, an RGB tuple, or a hex string. The example notes that integers are used for RGB values when colormode is 255.

```python
>>> turtle.fillcolor("violet")
>>> turtle.fillcolor()
'violet'
>>> turtle.pencolor()
(50.0, 193.0, 143.0)
>>> turtle.fillcolor((50, 193, 143))  # Integers, not floats
>>> turtle.fillcolor()
(50.0, 193.0, 143.0)
>>> turtle.fillcolor('#ffffff')
>>> turtle.fillcolor()
(255.0, 255.0, 255.0)
```

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

### Example: Using linecache.getline()

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

Shows how to retrieve a specific line from a file using linecache.getline(). The example gets line 8 from the linecache module's own source file and prints the line with its newline character.

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

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

### WSGI Application Example

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

A simple WSGI application example demonstrating the use of wsgiref.simple_server.make_server and wsgiref.util.setup_testing_defaults.

```APIDOC
## WSGI Application Example

### Description
A relatively simple WSGI application that prints out the environment dictionary after being updated by `setup_testing_defaults`.

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

def simple_app(environ, start_response):
    setup_testing_defaults(environ)
    status = '200 OK'
    headers = [('Content-type', 'text/plain; charset=utf-8')]
    start_response(status, headers)
    ret = [("%s: %s\n" % (key, value)).encode("utf-8") for key, value in environ.items()]
    return ret

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

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

### Example output for running 'ls /zzz'

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

Shows the output produced by the previous example when the command fails.

```text
['ls /zzz' exited with 1]
[stderr]
ls: /zzz: No such file or directory
```
Tokens:
Raw