Parsing and validation of URIs (RFC 3986) and IRIs (RFC 3987)

Warnings

• breaking The original GitHub repository for `rfc3987` has been archived by its owner, and development has reportedly moved to a different platform (Codeberg). This indicates that the PyPI package might not receive future updates or active maintenance from the original author, potentially leading to stagnation or unaddressed issues for newer Python versions or RFC amendments.
  Fix: Be aware that active development has shifted. For new projects, evaluate if the current 1.3.8 version meets your needs, or consider forks/alternative libraries if active maintenance is critical. The Codeberg repository (https://codeberg.org/atufi/rfc3987/) might contain more up-to-date information or development.
• gotcha The `parse` and `match` functions have different capabilities depending on whether the optional `regex` package is installed. If `regex` is available, any RFC 3986/3987 rule can be used. If only Python's built-in `re` module is present, only specific, special-cased rules (like 'IRI_reference', 'IRI', 'absolute_IRI', 'URI_reference', 'URI', etc.) are supported.
  Fix: If you need to validate or parse strings against arbitrary or less common RFC 3986/3987 rules, ensure you install the `regex` package: `pip install rfc3987 regex`. Otherwise, restrict rule usage to those explicitly supported by the `re` module fallback.
• deprecated The library primarily lists Python 2.x and Python 3.2-3.6 for compatibility testing in its PyPI metadata. While it generally works with newer Python 3 versions, explicit support, testing, and potential edge-case fixes for Python 3.7+ are not officially documented due to the lack of recent updates and archived status of the original repository.
  Fix: Test thoroughly on your target Python 3.x version. While the core regex patterns are stable, be mindful of potential unexpected behavior or lack of optimizations on newer Python runtimes.
• gotcha For older Python versions (<=3.2), characters beyond the Basic Multilingual Plane (BMP) might not be fully supported on 'narrow' Python builds, which can lead to issues when processing internationalized characters in IRIs. This is a Python interpreter limitation, not specific to `rfc3987` itself.
  Fix: Ensure you are using a modern Python 3.x version (preferably 3.7+) which typically supports a 'wide' Unicode build, resolving this limitation. This warning is less relevant for contemporary Python environments.

Install

• pip install rfc3987 Install stable version

Imports

• match

  from rfc3987 import match

• parse

  from rfc3987 import parse

• compose

  from rfc3987 import compose

• resolve

  from rfc3987 import resolve

Quickstart

Demonstrates parsing an IRI, matching a component against a rule, and resolving a relative URI reference. The `parse` function extracts components into a dictionary, `match` checks if a string conforms to a specific ABNF rule, and `resolve` combines a base URI with a relative reference.

from rfc3987 import parse, match, resolve

# Parse an IRI and get its components
iri_string = 'http://example.com/path?query=value#fragment'
parsed_iri = parse(iri_string, rule='IRI')
print(f"Parsed Scheme: {parsed_iri.get('scheme')}")
print(f"Parsed Authority: {parsed_iri.get('authority')}")
print(f"Parsed Path: {parsed_iri.get('path')}")

# Check if a string matches a specific rule
is_pct_encoded = match('%C7', 'pct_encoded')
print(f"Is '%C7' percent-encoded? {bool(is_pct_encoded)}")

# Resolve a relative URI reference
base_uri = 'http://a/b/c/d;p?q'
relative_ref = '../../g'
resolved_uri = resolve(base_uri, relative_ref)
print(f"Resolved URI: {resolved_uri}")