### Example GET Request with Parameters

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/server.md

An example of an HTTP GET request including label and value parameters for badge generation.

```http
GET /?label=Coverage&value=95% HTTP/1.1
Host: localhost:8000
```

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

### CLI Usage Examples

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/server.md

Demonstrates various ways to start the anybadge server from the command line, including specifying address and port, enabling debug mode, and utilizing environment variables for configuration.

```bash
# Start server on default localhost:8000
anybadge-server

# Start on custom port
anybadge-server -p 9000

# Start on all interfaces on port 5000
anybadge-server -l 0.0.0.0 -p 5000

# Enable debug logging
anybadge-server -d

# Use environment variables
export ANYBADGE_PORT=9000
export ANYBADGE_LISTEN_ADDRESS=0.0.0.0
anybadge-server
```

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

### Start anybadge Server

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/server.md

Start the anybadge server from the terminal. Use the -p flag to specify the port and -d for debug logging. This example shows starting on port 8000.

```bash
# Terminal 1: Start server on port 8000
anybadge-server -p 8000 -d  # With debug logging

# Terminal 2: Request a badge
curl "http://localhost:8000/?label=Build&value=passing"
# Returns: SVG badge with label "Build" and value "passing"
```

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

### Start Anybadge Server with Default Settings

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/endpoints.md

Starts the Anybadge server on the default host (localhost) and port (8000).

```bash
anybadge-server
```

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

### Start Anybadge Server Listening on All Interfaces

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/endpoints.md

Starts the Anybadge server and configures it to listen on all available network interfaces on a specified port.

```bash
anybadge-server --listen-address 0.0.0.0 --port 5000
```

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

### Start Anybadge Server with Debug Logging

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/endpoints.md

Starts the Anybadge server with debug logging enabled for more detailed output.

```bash
anybadge-server --debug
```

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

### Example GET Request Missing Parameters

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/server.md

An example of an HTTP GET request where label and value parameters are missing, triggering the help page response.

```http
GET / HTTP/1.1
Host: localhost:8000
```

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

### Start Anybadge Server on a Custom Port

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/endpoints.md

Starts the Anybadge server on a specified custom port.

```bash
anybadge-server --port 9000
```

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

### Install build requirements

Source: https://github.com/jongracecox/anybadge/blob/master/CONTRIBUTING.md

Install the necessary packages for building the project using pip.

```bash
pip install -r build-requirements.txt
```

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

### Install and activate pre-commit hooks

Source: https://github.com/jongracecox/anybadge/blob/master/CONTRIBUTING.md

Install pre-commit and activate it for the project to ensure code consistency and run safety checks before committing.

```bash
pip install pre-commit
pre-commit install
```

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

### run()

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/server.md

Starts and runs the anybadge HTTP server. It can be configured with a specific listen address and port.

```APIDOC
## run()

### Description
Starts and runs the anybadge HTTP server. It can be configured with a specific listen address and port.

### Method
```python
def run(
    listen_address: str | None = None,
    port: int | None = None
) -> None
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
from anybadge.server.cli import run

# Start server on default localhost:8000
run()

# Start on custom address
run(listen_address='0.0.0.0', port=9000)
```

### Response
#### Success Response
None

#### Response Example
None
```

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

### Start HTTP Server

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/README.md

Launch the Anybadge HTTP server to serve badges dynamically. The server defaults to port 8000.

```bash
# Start server on default port 8000
anybadge-server
```

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

### Build, install, and run CLI tests locally

Source: https://github.com/jongracecox/anybadge/blob/master/CONTRIBUTING.md

Build the package, install it locally, and then run CLI tests. This is particularly useful when actively developing CLI code, as it ensures changes are reflected in tests.

```bash
inv package.build && inv package.install && inv test.cli
```

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

### Example HTML Help Page Response

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/server.md

The HTML response served when required parameters are missing from a GET request.

```html
HTTP/1.1 200 OK
Content-type: text/html

<html>
  <head><title>Anybadge Web Server.</title></head>
  <body>
    <h1>Welcome to the Anybadge Web Server.</h1>
    <p>You are seeing this message because...</p>
    <a href="http://localhost:8000/?label=Project%20Awesomeness&value=110%">...</a>
  </body>
</html>
```

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

### Pre-commit hook example output

Source: https://github.com/jongracecox/anybadge/blob/master/CONTRIBUTING.md

Example output from pre-commit hooks indicating that files were modified and need to be re-added and re-committed.

```text
trim trailing whitespace.................................................Failed
- hook id: trailing-whitespace
- exit code: 1
- files were modified by this hook

Fixing tests/test_anybadge.py

fix end of files.........................................................Failed
- hook id: end-of-file-fixer
- exit code: 1
- files were modified by this hook

Fixing examples/color_teal.svg
```

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

### Example HEAD Request

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/server.md

An example of an HTTP HEAD request to the server.

```http
HEAD / HTTP/1.1
Host: localhost:8000
```

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

### Help Response for Missing Parameters

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/endpoints.md

This example shows the response when required parameters (label and value) are missing. It returns an HTML help page with usage instructions and an example link.

```http
GET / HTTP/1.1
Host: localhost:8000
```

```html
HTTP/1.1 200 OK
Content-type: text/html

<html>
  <head>
    <title>Anybadge Web Server.</title>
  </head>
  <body>
    <h1>Welcome to the Anybadge Web Server.</h1>
    <p>You are seeing this message because you haven't passed all the query parameters to display a badge.</p>
    <p>You need to pass at least a <b>label</b> and <b>value</b> parameter.</p>
    <p>Here is an example:</p>
    <p><a href="http://localhost:8000/?label=Project%20Awesomeness&value=110%">
      http://localhost:8000/?label=Project%20Awesomeness&value=110%
    </a></p>
  </body>
</html>
```

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

### Generate example badges markdown

Source: https://github.com/jongracecox/anybadge/blob/master/CONTRIBUTING.md

Run this task to regenerate the example badges markdown. This should be done whenever badge appearance or available colors are modified.

```bash
inv examples
```

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

### FONT_WIDTHS Configuration Example

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/configuration.md

Illustrates the structure for defining character widths for different fonts and sizes, crucial for accurate badge rendering.

```python
FONT_WIDTHS = {
    "DejaVu Sans,Verdana,Geneva,sans-serif": {
        10: 9,    # 10px font = 9px average character width
        11: 10,   # 11px font = 10px average character width
        12: 11,   # 12px font = 11px average character width
    },
    "Arial, Helvetica, sans-serif": {
        11: 8,    # 11px font = 8px average character width
    },
}
```

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

### Run local tests

Source: https://github.com/jongracecox/anybadge/blob/master/CONTRIBUTING.md

Execute local tests by first building and installing the package, then running the local test suite. This ensures the project builds and installs correctly.

```bash
inv package.build && inv package.install && inv test.local
```

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

### GitHub Readme Badge Example

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/README.md

Example Markdown for displaying badges in a GitHub README file. This shows how to link badges to relevant project pages or build statuses.

```markdown
# My Project

[![Build Status](https://github.com/user/repo/workflows/CI/badge.svg)](https://github.com/user/repo/actions)
[![Coverage](https://img.shields.io/badge/coverage-95%25-brightgreen)](https://github.com/user/repo)

Generated with anybadge.
```

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

### Install and run Tox tests

Source: https://github.com/jongracecox/anybadge/blob/master/CONTRIBUTING.md

Install the Tox testing tool and run tests against all supported Python versions. This ensures compatibility across different Python environments.

```bash
pip install tox
tox
```

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

### CLI Style Matching Example

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/style.md

Demonstrates how the Anybadge CLI parses a style name provided as an argument. It matches the style, extracts its properties, and creates a badge.

```bash
# Command:
anybadge --value=2.22 --file=pylint.svg pylint

# Parsing:
# 1. Detect 'pylint' matches Style.PYLINT
# 2. Extract: thresholds={2: 'red', 4: 'orange', 8: 'yellow', 10: 'green'}, label='pylint'
# 3. Create: Badge('pylint', 2.22, thresholds={...})
```

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

### Install Anybadge Package

Source: https://github.com/jongracecox/anybadge/blob/master/README.md

Install the latest release of the anybadge package from PyPi using pip. This command also makes the 'anybadge' utility available on the command line.

```bash
pip install anybadge
```

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

### Clone the anybadge repository

Source: https://github.com/jongracecox/anybadge/blob/master/CONTRIBUTING.md

Use this command to get a local copy of the project.

```bash
git clone https://github.com/jongracecox/anybadge.git
```

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

### Configure Anybadge Server via Environment Variables

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/endpoints.md

Sets environment variables to configure the Anybadge server's port, listen address, and log level before starting it.

```bash
export ANYBADGE_PORT=9000
export ANYBADGE_LISTEN_ADDRESS=0.0.0.0
export ANYBADGE_LOG_LEVEL=DEBUG
anybadge-server
```

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

### Run CLI tests against local install

Source: https://github.com/jongracecox/anybadge/blob/master/CONTRIBUTING.md

Execute command-line interface tests against a locally installed version of the package. Useful for verifying CLI functionality during development.

```bash
inv test.cli
```

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

### Main Server Entry Point

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/server.md

The main function to run the anybadge server, incorporating support for CLI arguments and environment variables. It handles configuration, logging setup, and initiates the server run process.

```python
from anybadge.server.cli import main

# When called as command-line entry point
main()
```

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

### Access Server from Application

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/server.md

Make a GET request to the running anybadge server to generate an SVG badge. The response content, which is the SVG, can then be saved to a file.

```python
import requests

# Request a badge from the server
response = requests.get('http://localhost:8000/', params={
    'label': 'Coverage',
    'value': '95%'
})

# Write SVG to file
with open('coverage.svg', 'wb') as f:
    f.write(response.content)
```

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

### Badge Generation URL Example

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/endpoints.md

Illustrates how to construct a URL to generate a badge with a specific label and value. Ensure query parameters are URL-encoded.

```http
GET /?label=<label>&value=<value> HTTP/1.1
Host: localhost:8000
```

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

### Run anybadge HTTP Server

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/server.md

Starts the anybadge HTTP server. It can be configured with a specific listen address and port, or it will use default values from the configuration. The server runs indefinitely until interrupted.

```python
from anybadge.server.cli import run

# Start server on default localhost:8000
run()

# Start on custom address
run(listen_address='0.0.0.0', port=9000)
```

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

### Get Python API Help for 'badge' function

Source: https://github.com/jongracecox/anybadge/blob/master/README.md

Displays the built-in help documentation for the 'badge' function within the anybadge Python library.

```python
from anybadge import badge
help(badge)
```

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

### List available invoke tasks

Source: https://github.com/jongracecox/anybadge/blob/master/CONTRIBUTING.md

Run this command to see all available automation tasks provided by the project's invoke setup. Useful for understanding project workflows.

```bash
> inv --list
Available tasks:

  examples              Generate examples markdown.
  colors.update         Generate colors Enum from Mozilla color keywords.
  housekeeping.clean    Clean up the project area.
  package.build         Build the package and write wheel to 'dist/' directory.
  package.install       Install the locally built version from 'dist/'.
  server.docker-build   Build docker image for anybadge server.
  server.docker-run     Run containerised anybadge server.
  server.run            Run local anybadge server.
  test.cli              Run CLI tests against currently installed version.
  test.docker           Run dockerised tests.
  test.local            Run local tests.
  test.pypi             Run tests against Pypi version.
```

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

### Display Anybadge Version

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/cli.md

Use this command to check the currently installed version of the anybadge package.

```bash
anybadge --version
```

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

### HTTP GET Request for Badge Generation

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/server.md

Handles GET requests to generate badges. It requires 'label' and 'value' query parameters. If parameters are missing, it serves an HTML help page.

```APIDOC
## GET /?label=<string>&value=<string>

### Description
Handles HTTP GET requests to generate badges. Requires 'label' and 'value' query parameters. If parameters are missing, an HTML help page is served.

### Method
GET

### Endpoint
/

### Parameters
#### Query Parameters
- **label** (str) - Required - Badge label text
- **value** (str) - Required - Badge value text

### Request Example
```
GET /?label=Coverage&value=95% HTTP/1.1
Host: localhost:8000
```

### Response
#### Success Response (200)
- **Content-Type**: text/html (for SVG or HTML response)

#### Response Example (SVG)
```
HTTP/1.1 200 OK
Content-type: text/html

<?xml version="1.0" encoding="UTF-8"?>
<svg xmlns="http://www.w3.org/2000/svg" ...>
  <!-- Badge SVG -->
</svg>
```

#### Response Example (HTML - Missing Parameters)
```
HTTP/1.1 200 OK
Content-type: text/html

<html>
  <head><title>Anybadge Web Server.</title></head>
  <body>
    <h1>Welcome to the Anybadge Web Server.</h1>
    <p>You are seeing this message because...</p>
    <a href="http://localhost:8000/?label=Project%20Awesomeness&value=110%">...</a>
  </body>
</html>
```
```

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

### Handle HTTP GET Requests for Badge Generation

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/server.md

Handles HTTP GET requests to generate badges. It parses label and value from query parameters. If parameters are missing, it serves an HTML help page.

```python
def do_GET(self) -> None:
    """Handle HTTP GET requests for badge generation."""
```

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

### Create Badge with Dynamic Coverage Value (Python)

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/README.md

Generate a coverage badge by calculating the coverage percentage and applying thresholds. Ensure the 'coverage' library is installed.

```python
from anybadge import Badge
import coverage

# Calculate coverage
cov = coverage.Coverage()
cov.load()
percent = cov.report()

# Create badge
badge = Badge(
    'Coverage',
    f'{percent:.1f}%',
    thresholds={50: 'red', 80: 'yellow', 100: 'green'},
    value_suffix='%'
)
badge.write_badge('coverage.svg', overwrite=True)
```

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

### Text Color Type Examples

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/types.md

Shows how to specify text colors for badge labels and values. Can be a single color for both or a comma-separated pair.

```python
text_color1: str = '#fff'      # White for both
text_color2: str = '#fff,#000' # White label, black value
```

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

### Badge Color Integration Examples

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/colors.md

Illustrates various ways colors are used within the Badge class, including threshold mapping, default color setting, and text color customization.

```python
thresholds = {50: 'red', 80: 'yellow', 100: 'green'}
```

```python
Badge('metric', 150, default_color='red')
```

```python
Badge('metric', '42', text_color='white,black')  # Label white, value black
```

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

### Example Error Messages

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/cli.md

Illustrates common error messages encountered due to invalid threshold formats or arguments.

```text
ERROR: Failed to parse threshold values: '2 red 4 orange'
ERROR: Thresholds should be in the form '<value>=color'
```

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

### Success Response with Parameters

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/endpoints.md

This is an example of a successful HTTP response when both label and value parameters are provided. The body contains SVG markup for the badge.

```http
HTTP/1.1 200 OK
Content-type: text/html

<?xml version="1.0" encoding="UTF-8"?>
<svg xmlns="http://www.w3.org/2000/svg" width="89" height="20">
    <linearGradient id="b" x2="0" y2="100%">
        <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
        <stop offset="1" stop-opacity=".1"/>
    </linearGradient>
    <mask id="a">
        <rect width="89" height="20" rx="3" fill="#fff"/>
    </mask>
    <g mask="url(#a)">
        <path fill="#555" d="M0 0h59v20H0z"/>
        <path fill="#green" d="M59 0h30v20H59z"/>
        ...
    </g>
    ...
</svg>
```

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

### Color Type Examples

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/types.md

Demonstrates valid formats for color values, including named colors from the `Color` enum and hex color codes.

```python
color1: str = 'red'           # Named color
color2: str = '#E05D44'       # Hex code
color3: str = '#4c1'          # Short hex code
```

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

### CLI Exit Code Example

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/errors.md

Shows how to capture and check the exit code from the `anybadge.cli.main()` function. An exit code of 1 indicates an error, such as invalid arguments or parsing failures.

```python
from anybadge.cli import main

exit_code = main(['--label', 'test', '--value', 'invalid', 'bad=threshold'])
print(exit_code)  # 1 (error)
```

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

### main()

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/server.md

Runs the anybadge server, supporting configuration via CLI arguments and environment variables.

```APIDOC
## main()

### Description
Runs the anybadge server, supporting configuration via CLI arguments and environment variables.

### Method
```python
def main() -> None
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Environment Variables
| Variable | Type | Description |
|----------|------|-------------|
| ANYBADGE_PORT | int | Override default port (must be valid integer) |
| ANYBADGE_LISTEN_ADDRESS | str | Override default listen address |
| ANYBADGE_LOG_LEVEL | str | Override default logging level (e.g., "DEBUG", "INFO") |

### CLI Usage
```bash
# Start server on default localhost:8000
anybadge-server

# Start on custom port
anybadge-server -p 9000

# Start on all interfaces on port 5000
anybadge-server -l 0.0.0.0 -p 5000

# Enable debug logging
anybadge-server -d

# Use environment variables
export ANYBADGE_PORT=9000
export ANYBADGE_LISTEN_ADDRESS=0.0.0.0
anybadge-server
```

### Request Example
```python
from anybadge.server.cli import main

# When called as command-line entry point
main()
```

### Response
#### Success Response
None

#### Response Example
None
```

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

### CLI Threshold Parsing Error Example

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/errors.md

Demonstrates the expected output when malformed threshold arguments are provided to the CLI. Thresholds should be in the format '<value>=<color>' separated by spaces.

```bash
anybadge --label test --value 42 2 red 4 orange
# Output:
# ERROR: Failed to parse threshold values: '2 red 4 orange'
# ERROR: Thresholds should be in the form '<value>=color>'
```

```bash
anybadge --label test --value 42 2=red 4=orange
```

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

### Create COVERAGE Badge using Style Enum

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/style.md

Create a badge for code coverage percentages using the COVERAGE style enum. This example also demonstrates applying a value suffix.

```python
from anybadge import Badge

# Using COVERAGE style with value suffix
badge = Badge('coverage', 95, value_suffix='%', thresholds={50: 'red', 60: 'orange', 80: 'yellow', 100: 'green'})

# Simpler: CLI automatically applies suffix
# anybadge --value=95 --file=coverage.svg coverage
```

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

### Example SVG Badge Response

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/server.md

The expected SVG response when a GET request successfully generates a badge.

```xml
HTTP/1.1 200 OK
Content-type: text/html

<?xml version="1.0" encoding="UTF-8"?>
<svg xmlns="http://www.w3.org/2000/svg" ...>
  <!-- Badge SVG -->
</svg>
```

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

### Using Styles in CLI

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/style.md

Illustrates how to use style names directly in the Anybadge command-line interface to automatically apply predefined thresholds and labels, simplifying badge generation.

```bash
# Instead of specifying thresholds manually:
anybadge -l pylint -v 2.22 -f pylint.svg 2=red 4=orange 8=yellow 10=green

# Use the style name:
anybadge -v 2.22 -f pylint.svg pylint
```

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

### URL Encoded Badge Examples

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/endpoints.md

Provides examples of URL-encoded query parameters for generating badges with different labels and values. Spaces and special characters must be encoded.

```http
/?label=Coverage&value=95%25
```

```http
/?label=Build%20Status&value=passing
```

```http
/?label=Python&value=3.9
```

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

### Importing from Submodules

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/types.md

Illustrates various import paths for accessing specific components from different submodules within the 'anybadge' library.

```python
from anybadge.badge import Badge
from anybadge.colors import Color
from anybadge.styles import Style
from anybadge.templates import get_template
from anybadge.exceptions import UnknownBadgeTemplate
from anybadge.helpers import is_emoji, _get_approx_string_width
from anybadge.cli import main, parse_args
from anybadge.server.cli import run, main as server_main
from anybadge.server.request_handler import AnyBadgeHTTPRequestHandler
```

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

### Display Anybadge Help Message

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/cli.md

This command shows the complete help message, listing all available arguments and their usage.

```bash
anybadge --help
```

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

### Create a Badge Using Predefined Styles

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/cli.md

Utilize built-in styles like 'pylint' or 'coverage' to automatically set thresholds and colors. The 'coverage' style also supports a '%' suffix.

```bash
# Uses PYLINT style with automatic thresholds
anybadge --value=2.22 --file=pylint.svg pylint

# Uses COVERAGE style with automatic thresholds and "%"suffix
anybadge --value=65 --file=coverage.svg coverage
```

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

### Instantiate Badge with Parsed Arguments

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/cli.md

This snippet shows how the CLI parses arguments and uses them to create a Badge instance. It covers various customization options for the badge.

```python
badge = Badge(
    label=args.label,
    value=args.value,
    value_prefix=args.prefix,
    value_suffix=suffix,
    default_color=args.color,
    num_padding_chars=args.padding,
    num_label_padding_chars=args.label_padding,
    num_value_padding_chars=args.value_padding,
    font_name=args.font,
    font_size=args.font_size,
    template=args.template,
    style=args.style,
    use_max_when_value_exceeds=args.use_max,
    thresholds=threshold_dict,
    value_format=args.value_format,
    text_color=args.text_color,
    semver=args.semver,
    escape_label=not args.no_escape_label,
    escape_value=not args.no_escape_value,
)
```

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

### Get Badge Representation

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/badge.md

The `__repr__` method returns a string that can be used to recreate the Badge object. This is helpful for debugging and serialization.

```python
badge = Badge('example', '123.456', value_suffix='TB')
print(repr(badge))  
# Outputs: Badge('example', '123.456', value_suffix='TB')
```

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

### Get Encoded Value Text

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/badge.md

Returns the value text with HTML characters escaped or unescaped, based on the `escape_value` setting.

```python
badge = Badge('label', 'value')
encoded_value = badge.encoded_value
```

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

### Get Encoded Label Text

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/badge.md

Returns the label text with HTML characters escaped or unescaped, depending on the `escape_label` setting.

```python
badge = Badge('label', 'value')
encoded_label = badge.encoded_label
```

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

### Get Complete SVG Markup

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/badge.md

Retrieve the full SVG text for the badge. This property returns the rendered SVG markup as a string.

```python
badge = Badge('coverage', '95%')
svg_text = badge.badge_svg_text
# Returns complete SVG markup
```

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

### Importing from Main Package

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/types.md

Standard import statement for core components directly from the main 'anybadge' package.

```python
from anybadge import Badge, Color, Style
```

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

### Path Handling with Strings and Path Objects

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/types.md

Illustrates writing badges using file paths provided as either standard strings or `pathlib.Path` objects.

```python
from pathlib import Path

# String path
badge.write_badge('output/badge.svg')

# Path object
badge.write_badge(Path('output') / 'badge.svg')
```

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

### Import Paths

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/types.md

Shows the available import paths for Anybadge components.

```APIDOC
## Import Paths

### From Main Package
```python
from anybadge import Badge, Color, Style
```

### From Submodules
```python
from anybadge.badge import Badge
from anybadge.colors import Color
from anybadge.styles import Style
from anybadge.templates import get_template
from anybadge.exceptions import UnknownBadgeTemplate
from anybadge.helpers import is_emoji, _get_approx_string_width
from anybadge.cli import main, parse_args
from anybadge.server.cli import run, main as server_main
from anybadge.server.request_handler import AnyBadgeHTTPRequestHandler
```
```

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

### Get Average Character Width

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/badge.md

Retrieves the average pixel width of a character based on the selected font and size. This value is sourced from config.FONT_WIDTHS.

```python
badge = Badge(label='x', value='1')
print(badge.font_width)  # Outputs: 10
```

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

### Generate Badge via CLI (Predefined Style)

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/README.md

Use the command-line interface to create a badge, specifying the value, file, and label.

```bash
# Using predefined style
anybadge --value=2.22 --file=pylint.svg pylint
```

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

### Validate Badge Configuration Options

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/configuration.md

Demonstrates how to validate font, template, and color configurations when initializing a Badge object. Catches specific exceptions for invalid inputs.

```python
from anybadge import Badge
from anybadge.exceptions import UnknownBadgeTemplate

# Validate font
try:
    badge = Badge('test', 'value', font_name='InvalidFont')
except ValueError as e:
    print(f"Invalid font: {e}")

# Validate template
try:
    badge = Badge('test', 'value', template='nonexistent.svg')
except UnknownBadgeTemplate:
    print("Invalid template")

# Validate color
try:
    badge = Badge('test', 'value', default_color='invalidcolor')
    color = badge.badge_color_code  # Actual validation happens here
except ValueError as e:
    print(f"Invalid color: {e}")
```

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

### Get Badge SVG Text

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/badge.md

The `__str__` method returns the raw SVG markup for the badge. This allows direct use or inspection of the generated SVG.

```python
badge = Badge('example', '123')
print(str(badge))  # Prints the SVG XML
```

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

### Module Structure

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/README.md

Overview of the Anybadge project's directory and file structure.

```text
anybadge/
├── badge.py           # Badge class
├── colors.py          # Color enum
├── styles.py          # Style enum
├── config.py          # Configuration defaults
├── exceptions.py      # Custom exceptions
├── helpers.py         # Utility functions
├── cli.py             # Command-line interface
├── templates/         # SVG templates
│   ├── default.svg
│   ├── gitlab_scoped.svg
│   └── __init__.py
└── server/            # HTTP server
    ├── request_handler.py
    ├── cli.py
    ├── config.py
    └── __init__.py
```

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

### anybadge main function

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/cli.md

The main entry point for the anybadge CLI. It takes a list of string arguments and generates a badge, writing it to a file or standard output. It returns an integer exit code.

```APIDOC
## main

### Description
Generate a badge based on command-line arguments and write it to a file or stdout.

### Signature
```python
def main(args: list[str] | None = None) -> int
```

### Parameters
#### Arguments
- **args** (list[str] | None) - Optional - Command-line arguments. If None, uses sys.argv[1:].

### Returns
- **int** - Exit code: 0 on success, 1 on error

### Example
```python
from anybadge.cli import main

# Generate badge from arguments
exit_code = main(['--label', 'coverage', '--value', '95', '--file', 'coverage.svg'])
```
```

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

### GitHub README Badge Integration

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/endpoints.md

Markdown snippet for embedding an Anybadge status badge directly into a GitHub README file. This example shows how to link the badge to a repository.

```markdown
# My Project

[![Build Status](http://localhost:8000/?label=Build&value=passing)](https://github.com/user/repo)

## About

This project uses anybadge for status badges.
```

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

### Docker Deployment of Anybadge Server

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/endpoints.md

Dockerfile to build an image for the Anybadge server and a bash command to run it. The server can be accessed at http://localhost:8000.

```dockerfile
FROM python:3.9
RUN pip install anybadge
EXPOSE 8000
CMD ["anybadge-server", "--listen-address", "0.0.0.0"]
```

```bash
docker run -p 8000:8000 anybadge-server
# Access at: http://localhost:8000/?label=Docker&value=running
```

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

### Badge Generation Endpoint

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/DOCUMENTATION_MANIFEST.txt

The main endpoint for generating badges via HTTP requests. It supports GET requests to create SVG badges based on provided parameters.

```APIDOC
## GET /

### Description
Generates an SVG badge based on the provided query parameters.

### Method
GET

### Endpoint
/

### Query Parameters
- **label** (string) - Optional - The text to display on the left side of the badge.
- **value** (string) - Optional - The text to display on the right side of the badge.
- **color** (string) - Optional - The color of the badge. Can be a named color or a hex code.
- **template** (string) - Optional - The name of the SVG template to use for rendering the badge.
- **style** (string) - Optional - The style of the badge (e.g., PYLINT, COVERAGE).

### Response
#### Success Response (200)
- **Content-Type**: `image/svg+xml`
- **Body**: SVG content of the generated badge.
```

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

### Instantiate Badge Class

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/badge.md

Use the Badge constructor to create a badge instance. Provide a label and value, and optionally configure font, padding, style, and colors.

```python
Badge(
    label='version',
    value='1.0.0',
    font_name='DejaVu Sans,Verdana,Geneva,sans-serif',
    font_size=11,
    num_padding_chars=0.5,
    num_label_padding_chars=0.5,
    num_value_padding_chars=0.5,
    template='default',
    style='default',
    value_prefix='',
    value_suffix='',
    thresholds=None,
    default_color='#4c1',
    use_max_when_value_exceeds=True,
    value_format=None,
    text_color='#fff',
    semver=False,
    escape_label=True,
    escape_value=True
)
```

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

### Custom Font and Size via CLI

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/configuration.md

Configure custom fonts and font sizes directly from the command line for badge customization.

```bash
anybadge --label test --value pass --font "Arial, Helvetica, sans-serif" --font-size 12 --file test.svg
```

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

### Generic List Type

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/types.md

Demonstrates the generic type hint for lists, specifying the type of elements they contain. Examples include lists of strings for command-line arguments and threshold pairs.

```python
list[str]
```

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

### Server Configuration Defaults

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/server.md

These are the default configuration values for the anybadge server. They can be overridden by environment variables, command-line arguments, or direct assignment in code.

```python
DEFAULT_SERVER_PORT: int = 8000
DEFAULT_SERVER_LISTEN_ADDRESS: str = "localhost"
DEFAULT_LOGGING_LEVEL = logging.INFO
SERVER_PORT: int = DEFAULT_SERVER_PORT
SERVER_LISTEN_ADDRESS: str = DEFAULT_SERVER_LISTEN_ADDRESS
```

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

### Anybadge API Endpoint

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/endpoints.md

The Anybadge API allows users to generate custom SVG badges by providing label and value parameters. It can be accessed via HTTP GET requests.

```APIDOC
## GET /

### Description
Generates an SVG badge with a specified label and value.

### Method
GET

### Endpoint
/

### Parameters
#### Query Parameters
- **label** (string) - Required - The text to display on the left side of the badge.
- **value** (string) - Required - The text to display on the right side of the badge.

### Request Example
```json
{
  "example": "curl \"http://localhost:8000/?label=Coverage&value=95%\""
}
```

### Response
#### Success Response (200)
- **SVG** (string) - The generated SVG code for the badge.

#### Response Example
```json
{
  "example": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"89\" height=\"20\">\n    <defs>\n        <linearGradient id=\"b\" x2=\"0\" y2=\"100%\">\n            <stop offset=\"0\" stop-color=\"#bbb\" stop-opacity=\".1\"/>\n            <stop offset=\"1\" stop-opacity=\".1\"/>\n        </linearGradient>\n    </defs>\n    <mask id=\"a\">\n        <rect width=\"89\" height=\"20\" rx=\"3\" fill=\"#fff\"/>\n    </mask>\n    <g mask=\"url(#a)\">\n        <path fill=\"#555\" d=\"M0 0h59v20H0z\"/>\n        <path fill=\"#4c1\" d=\"M59 0h30v20H59z\"/>\n        <path fill=\"url(#b)\" d=\"M0 0h89v20H0z\"/>\n    </g>\n    <g fill=\"#fff\" text-anchor=\"middle\" font-family=\"DejaVu Sans,Verdana,Geneva,sans-serif\" font-size=\"11\">\n        <text x=\"305\" y=\"150\" fill=\"#010101\" fill-opacity=\".3\">Label</text>\n        <text x=\"304\" y=\"149\">Label</text>\n    </g>\n    <g fill=\"#fff\" text-anchor=\"middle\" font-family=\"DejaVu Sans,Verdana,Geneva,sans-serif\" font-size=\"11\">\n        <text x=\"735\" y=\"150\" fill=\"#010101\" fill-opacity=\".3\">Value</text>\n        <text x=\"734\" y=\"149\">Value</text>\n    </g>\n</svg>"
}
```
```

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

### Generate Badge with Template

Source: https://github.com/jongracecox/anybadge/blob/master/README.md

Use a predefined template to generate a badge with a specified value and output file. This is useful for quick badge generation based on common metrics.

```bash
anybadge --value=<VALUE> --file=<FILE> <TEMPLATE-NAME>
```

```bash
anybadge --value=2.22 --file=pylint.svg pylint
```

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

### Generate Coverage Badge with Suffix and Thresholds (CLI Alternative)

Source: https://github.com/jongracecox/anybadge/blob/master/README.md

Alternative command-line syntax for generating a coverage badge, including a suffix (e.g., '%') and color thresholds.

```bash
anybadge.py --label=coverage --value=65 --suffix='%%' --file=coverage.svg 50=red 60=orange 80=yellow 100=green
```

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

### Basic cURL Request

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/endpoints.md

Use cURL to make a basic GET request to the API endpoint to generate a badge. The label and value parameters define the badge's content.

```bash
# Basic request
curl "http://localhost:8000/?label=Coverage&value=95%"
```

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

### Create a Simple Badge (Python API)

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/README.md

Use the Python API to create a basic badge with a label and value, and write it to an SVG file.

```python
from anybadge import Badge

# Create a simple badge
badge = Badge('coverage', '95%', default_color='green')
badge.write_badge('coverage.svg', overwrite=True)
```

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

### Generic Dictionary Type

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/types.md

Shows the generic type hint for dictionaries, specifying key and value types. Examples include mapping numeric values to colors and string values to colors.

```python
dict[float, str]

dict[str, str]
```

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

### Modifying Default Configuration

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/configuration.md

Demonstrates how to change global default settings for font and font size for all subsequently created badges.

```python
from anybadge import Badge, config

# Change default font for all subsequent badges
config.DEFAULT_FONT = "Arial, Helvetica, sans-serif"
config.DEFAULT_FONT_SIZE = 12

# Create badge with new defaults
badge = Badge('label', 'value')  # Uses modified defaults

# Or override per-instance
badge2 = Badge('label', 'value', 
               font_name="DejaVu Sans,Verdana,Geneva,sans-serif",
               font_size=11)
```

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

### Create a Simple Badge with Fixed Color

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/cli.md

Use this command to generate a badge with a specific label, value, and color. The output is saved to a file.

```bash
anybadge --label="Awesomeness" --value="110%" --color="#97CA00" --file=awesomeness.svg
```

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

### Setting Project-Wide Badge Defaults

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/configuration.md

Configure project-wide default settings for badges, such as font, font size, and default color, using the `anybadge.config` module. This allows for consistent badge styling across a project.

```python
# project_badges.py
from anybadge import Badge, config

# Set project-wide defaults
config.DEFAULT_FONT = "Arial, Helvetica, sans-serif"
config.DEFAULT_FONT_SIZE = 12
config.DEFAULT_COLOR = "#0066cc"

def create_project_badge(label, value, **kwargs):
    """Create badge with project defaults"""
    return Badge(label, value, **kwargs)
```

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

### Safe Badge Creation with Error Handling

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/errors.md

Illustrates how to safely create a `Badge` object, catching `UnknownBadgeTemplate` and `ValueError` exceptions. It includes fallback mechanisms for invalid templates or values.

```python
from anybadge import Badge
from anybadge.exceptions import UnknownBadgeTemplate

def create_badge_safely(label, value, template='default'):
    try:
        return Badge(label, value, template=template)
    except UnknownBadgeTemplate:
        # Fall back to default template
        return Badge(label, value, template='default')
    except ValueError as e:
        # Use empty label if both are invalid
        return Badge('badge', value)
```

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

### Run containerized tests

Source: https://github.com/jongracecox/anybadge/blob/master/CONTRIBUTING.md

Execute tests within a Docker container to ensure the package behaves as expected when installed, independent of the local development environment. This is a final check before pushing changes.

```bash
inv test.docker
```

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

### Semantic Version Support in Anybadge

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/README.md

Compare values as semantic versions to ensure correct version ordering. Set `semver=True` for version comparisons.

```python
badge = Badge(
    'version',
    '2.1.0',
    thresholds={'1.0.0': 'red', '2.0.0': 'yellow', '3.0.0': 'green'},
    semver=True
)
# 2.1.0 < 3.0.0, so badge is green
```

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

### Custom Formatting for Badge Value

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/cli.md

Control the display format of the badge value using standard printf-style format specifiers. This example formats the value to one decimal place and adds a '%' suffix.

```bash
anybadge --label=coverage --value=95.5 --value-format="%.1f" --suffix="%" --file=coverage.svg 50=red 80=yellow 100=green
```

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

### View All Contributors

Source: https://github.com/jongracecox/anybadge/blob/master/AUTHORS.rst

Use this command to list all unique contributors to the project.

```bash
git log --format='%aN' | sort -u
```

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

### Get Hex Color Code for Badge

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/badge.md

Returns the hex color code corresponding to the current badge color. This property may raise a ValueError if the color name is invalid or not found in the Color enum.

```python
badge = Badge('status', 'passing', thresholds={'passing': 'green'})
print(badge.badge_color_code)  # Outputs: '#4C1' (hex for 'green')
```

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

### Default Configuration Variables

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/configuration.md

Defines default values for font, padding, colors, and SVG mask prefixes used by anybadge.

```python
DEFAULT_FONT: str = "DejaVu Sans,Verdana,Geneva,sans-serif"
DEFAULT_FONT_SIZE: int = 11
NUM_PADDING_CHARS: float = 0.5
DEFAULT_COLOR: str = "#4c1"
DEFAULT_TEXT_COLOR: str = "#fff"
MASK_ID_PREFIX: str = "anybadge_"

FONT_WIDTHS: Dict[str, Dict[int, int]] = {
    "DejaVu Sans,Verdana,Geneva,sans-serif": {
        10: 9,
        11: 10,
        12: 11,
    },
    "Arial, Helvetica, sans-serif": {
        11: 8,
    },
}
```

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

### Example Custom SVG Badge Template

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/templates.md

This XML snippet demonstrates a custom SVG template for creating badges. It uses various template variables like '{{ badge width }}', '{{ mask id }}', and '{{ label }}' to dynamically generate the badge's appearance and content. Ensure unique mask IDs are used to prevent rendering conflicts.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<svg xmlns="http://www.w3.org/2000/svg" width="{{ badge width }}" height="20">
    <defs>
        <linearGradient id="grad{{ mask id }}" x2="0" y2="100%">
            <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
            <stop offset="1" stop-opacity=".1"/>
        </linearGradient>
    </defs>
    
    <g>
        <path fill="#555" d="M0 0h{{ color split x }}v20H0z"/>
        <path fill="{{ color }}" d="M{{ color split x }} 0h{{ value width }}v20H{{ color split x }}z"/>
        <path fill="url(#grad{{ mask id }})" d="M0 0h{{ badge width }}v20H0z"/>
    </g>
    
    <g fill="{{ label text color }}" text-anchor="middle" font-family="{{ font name }}" font-size="{{ font size }}">
        <text x="{{ label anchor shadow }}" y="15" fill="#010101" fill-opacity=".3">{{ label }}</text>
        <text x="{{ label anchor }}" y="14">{{ label }}</text>
    </g>
    
    <g fill="{{ value text color }}" text-anchor="middle" font-family="{{ font name }}" font-size="{{ font size }}">
        <text x="{{ value anchor shadow }}" y="15" fill="#010101" fill-opacity=".3">{{ value }}</text>
        <text x="{{ value anchor }}" y="14">{{ value }}</text>
    </g>
</svg>
```

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

### Generate Badge via CLI (Custom Thresholds)

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/README.md

Create a badge using the CLI with custom color thresholds defined directly in the command.

```bash
# With custom thresholds
anybadge --label=coverage --value=95 --suffix='%' --file=coverage.svg \
  50=red 60=orange 80=yellow 100=green
```

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

### Integrate Server in Python Application

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/server.md

Run the anybadge server in a background thread within a Python application. This allows the server to run concurrently with your main application logic.

```python
from anybadge.server.cli import run
import threading

# Start server in background thread
server_thread = threading.Thread(target=run, kwargs={'listen_address': '0.0.0.0', 'port': 9000})
server_thread.daemon = True
server_thread.start()

# Now make requests to http://localhost:9000/?label=...&value=...
```

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

### Parse Server Command-Line Arguments

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/api-reference/server.md

Parses command-line arguments for the anybadge server. It supports arguments for port, listen address, and debug mode. These can be overridden by environment variables.

```python
from anybadge.server.cli import parse_args

args = parse_args()  # or with: ['-p', '9000', '--debug']
print(args.port)     # 8000 or 9000
print(args.debug)    # False or True
```

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

### Safe File Writing with Error Handling

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/errors.md

Demonstrates a safe method for writing badges to a file, handling `RuntimeError` (file exists) and `ValueError` (invalid path). It includes logic for creating backup files.

```python
from pathlib import Path
from anybadge import Badge

def write_badge_safely(badge, file_path):
    try:
        badge.write_badge(file_path, overwrite=False)
        return True
    except RuntimeError:
        # File exists, ask user or use backup name
        backup_path = Path(file_path).with_stem(Path(file_path).stem + '_backup')
        badge.write_badge(backup_path, overwrite=True)
        return False
    except ValueError:
        # Path is invalid or directory
        print("Invalid file path")
        return False
```

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

### Default Server Configuration Variables

Source: https://github.com/jongracecox/anybadge/blob/master/_autodocs/configuration.md

Defines the default values for server port, listen address, and logging level in the configuration module.

```python
import logging

DEFAULT_SERVER_PORT: int = 8000
DEFAULT_SERVER_LISTEN_ADDRESS: str = "localhost"
DEFAULT_LOGGING_LEVEL = logging.INFO
SERVER_PORT: int = DEFAULT_SERVER_PORT
SERVER_LISTEN_ADDRESS: str = DEFAULT_SERVER_LISTEN_ADDRESS
```