fastapi-ipware 0.1.1__tar.gz → 0.2.0__tar.gz

fastapi_ipware-0.2.0/PKG-INFO

@@ -0,0 +1,230 @@
+Metadata-Version: 2.3
+Name: fastapi-ipware
+Version: 0.2.0
+Summary: FastAPI/Starlette-native wrapper for python-ipware to get client IP addresses
+Keywords: fastapi,starlette,ipware,ip-address,client-ip,proxy,x-forwarded-for
+Author: Michael Bianco
+Author-email: Michael Bianco <mike@mikebian.co>
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: python-ipware>=4.1.0
+Requires-Dist: starlette>=0.49.1
+Requires-Python: >=3.12
+Project-URL: Repository, https://github.com/iloveitaly/fastapi-ipware
+Description-Content-Type: text/markdown
+
+[![Release Notes](https://img.shields.io/github/release/iloveitaly/fastapi-ipware)](https://github.com/iloveitaly/fastapi-ipware/releases)
+[![Downloads](https://static.pepy.tech/badge/fastapi-ipware/month)](https://pepy.tech/project/fastapi-ipware)
+![GitHub CI Status](https://github.com/iloveitaly/fastapi-ipware/actions/workflows/build_and_publish.yml/badge.svg)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+# fastapi-ipware
+
+A FastAPI/Starlette-native wrapper for [python-ipware](https://github.com/un33k/python-ipware) that eliminates the need for WSGI-style header conversion.
+
+`python-ipware` expects WSGI-style headers (`HTTP_X_FORWARDED_FOR`), but FastAPI uses natural header names (`X-Forwarded-For`). This wrapper handles the conversion automatically so you don't have to.
+
+Also, the default precedence order is optimized for modern cloud deployments. See the [default precedence configuration](https://github.com/iloveitaly/fastapi-ipware/blob/main/fastapi_ipware/__init__.py#L48-L58) in the source code. This is different from the
+default ordering ipware which deprioritizes platform-specific headers, which is often the wrong ordering if you are using something like CloudFlare.
+
+## Features
+
+- **Zero conversion overhead** - Headers converted once at initialization, not on every request
+- **FastAPI-native API** - Works directly with FastAPI/Starlette `Request` objects
+- **Customizable precedence** - Easy to configure header priority for your infrastructure
+- **Proxy validation** - Supports trusted proxy lists and proxy count validation
+
+## Installation
+
+```bash
+uv add fastapi-ipware
+```
+
+## Quick Start
+
+`trusted` is true only when the request came through the proxies configured with `proxy_count` or `proxy_list`.
+
+`proxy_count=N` returns the address just left of the N rightmost proxies, instead of the first public address, and rejects a shorter chain. `X-Forwarded-For: 203.0.113.10, 10.0.0.1, 10.0.0.2` returns `203.0.113.10` with no `proxy_count`, and `10.0.0.1` with `proxy_count=1`.
+
+### Using FastAPI Dependency Injection
+
+```python
+from typing import Annotated
+from fastapi import Depends, FastAPI
+from fastapi_ipware import ClientIpResult, FastAPIIpWare
+
+app = FastAPI()
+ipware = FastAPIIpWare()
+
+
+@app.get("/")
+async def get_ip(client: Annotated[ClientIpResult, Depends(ipware)]):
+    ip, trusted = client
+    return {
+        "ip": str(ip) if ip else None,
+        "trusted": trusted,
+        "is_public": ip.is_global if ip else None,
+    }
+
+
+# Or inject only the IP object or string directly:
+@app.get("/ip-string")
+async def get_ip_string(ip_str: Annotated[str | None, Depends(ipware.get_ip_str)]):
+    return {"ip": ip_str}
+```
+
+### Using Request Directly
+
+```python
+from fastapi import FastAPI, Request
+from fastapi_ipware import FastAPIIpWare
+
+app = FastAPI()
+ipware = FastAPIIpWare()
+
+
+@app.get("/")
+async def get_ip(request: Request):
+    ip, trusted = ipware.get_client_ip_from_request(request)
+    return {"ip": str(ip) if ip else None, "trusted": trusted}
+```
+
+### Using ASGI Middleware
+
+Automatically extract the client IP onto `request.state` for every request:
+
+```python
+from fastapi import FastAPI, Request
+from fastapi_ipware import IpWareMiddleware
+
+app = FastAPI()
+app.add_middleware(IpWareMiddleware)
+
+
+@app.get("/")
+async def get_ip(request: Request):
+    return {
+        "ip": request.state.client_ip_str,
+        "trusted": request.state.ip_trusted,
+    }
+```
+
+Pass a configured resolver when you need one. Omit `strict` to use that resolver's `default_strict`; pass `strict=` to override it.
+
+```python
+from fastapi_ipware import FastAPIIpWare, IpWareMiddleware
+
+ipware = FastAPIIpWare(proxy_count=1, default_strict=True)
+app.add_middleware(IpWareMiddleware, ipware=ipware)
+```
+
+### Custom Header Precedence
+
+Customize which headers are checked and in what order:
+
+```python
+# Prioritize Cloudflare headers
+ipware = FastAPIIpWare(
+    precedence=(
+        "CF-Connecting-IP",
+        "X-Forwarded-For",
+        "X-Real-IP",
+    )
+)
+
+# NGINX configuration
+ipware = FastAPIIpWare(
+    precedence=(
+        "X-Real-IP",
+        "X-Forwarded-For",
+    )
+)
+```
+
+### Proxy Count Validation
+
+Validate that requests pass through the expected number of proxies:
+
+```python
+# Expect exactly 1 proxy (e.g., AWS ALB).
+# default_strict applies to Depends(ipware), dependency(), and IpWareMiddleware.
+ipware = FastAPIIpWare(proxy_count=1, default_strict=True)
+
+# In strict mode, must be exactly 1 proxy
+ip, trusted = ipware.get_client_ip_from_request(request, strict=True)
+
+# In non-strict mode, allow 1 or more proxies
+ip, trusted = ipware.get_client_ip_from_request(request, strict=False)
+```
+
+### Trusted Proxy List
+
+Validate that requests pass through specific trusted proxies (supports IP prefixes, exact IPs, and CIDR networks):
+
+```python
+# Trust specific proxy IP prefixes or CIDR networks
+ipware = FastAPIIpWare(
+    proxy_list=["10.0.", "10.1.", "100.64.0.0/10"]  # AWS internal IPs and CGNAT CIDR
+)
+
+ip, trusted = ipware.get_client_ip_from_request(request)
+
+# trusted=True only if request came through specified proxies
+```
+
+### Combined Validation
+
+Use both proxy count and trusted proxy list:
+
+```python
+# Expect 1 proxy from a specific IP range
+ipware = FastAPIIpWare(proxy_count=1, proxy_list=["10.0."])
+```
+
+### Algorithm Engine Selection
+
+Choose between python-ipware 4.x engines (`auto` / `modern` / `legacy`):
+
+```python
+# Modern engine (default): enhanced header parsing and RFC 7239 support
+ipware = FastAPIIpWare(algorithm="modern")
+
+# Legacy engine: frozen byte-for-byte v3 behavior
+ipware = FastAPIIpWare(algorithm="legacy")
+```
+
+## IP Address Types
+
+The returned IP address object has useful properties:
+
+```python
+ip, _ = ipware.get_client_ip_from_request(request)
+
+if ip:
+    print(f"Is public: {ip.is_global}")
+    print(f"Is private: {ip.is_private}")
+    print(f"Is loopback: {ip.is_loopback}")
+    print(f"Is multicast: {ip.is_multicast}")
+```
+
+python-ipware automatically prefers:
+
+1. Public (global) IPs first
+2. Private IPs second
+3. Loopback IPs last
+
+## License
+
+[MIT License](LICENSE.md)
+
+## Credits
+
+- Built on top of [python-ipware](https://github.com/un33k/python-ipware) by un33k.
+- https://github.com/long2ice/fastapi-limiter/blob/8d179c058fa2aaf98f3450c9026a7300ae2b3bdd/fastapi_limiter/__init__.py#L11
+
+---
+
+*This project was created from [iloveitaly/python-package-template](https://github.com/iloveitaly/python-package-template)*

fastapi_ipware-0.2.0/README.md

@@ -0,0 +1,212 @@
+[![Release Notes](https://img.shields.io/github/release/iloveitaly/fastapi-ipware)](https://github.com/iloveitaly/fastapi-ipware/releases)
+[![Downloads](https://static.pepy.tech/badge/fastapi-ipware/month)](https://pepy.tech/project/fastapi-ipware)
+![GitHub CI Status](https://github.com/iloveitaly/fastapi-ipware/actions/workflows/build_and_publish.yml/badge.svg)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+# fastapi-ipware
+
+A FastAPI/Starlette-native wrapper for [python-ipware](https://github.com/un33k/python-ipware) that eliminates the need for WSGI-style header conversion.
+
+`python-ipware` expects WSGI-style headers (`HTTP_X_FORWARDED_FOR`), but FastAPI uses natural header names (`X-Forwarded-For`). This wrapper handles the conversion automatically so you don't have to.
+
+Also, the default precedence order is optimized for modern cloud deployments. See the [default precedence configuration](https://github.com/iloveitaly/fastapi-ipware/blob/main/fastapi_ipware/__init__.py#L48-L58) in the source code. This is different from the
+default ordering ipware which deprioritizes platform-specific headers, which is often the wrong ordering if you are using something like CloudFlare.
+
+## Features
+
+- **Zero conversion overhead** - Headers converted once at initialization, not on every request
+- **FastAPI-native API** - Works directly with FastAPI/Starlette `Request` objects
+- **Customizable precedence** - Easy to configure header priority for your infrastructure
+- **Proxy validation** - Supports trusted proxy lists and proxy count validation
+
+## Installation
+
+```bash
+uv add fastapi-ipware
+```
+
+## Quick Start
+
+`trusted` is true only when the request came through the proxies configured with `proxy_count` or `proxy_list`.
+
+`proxy_count=N` returns the address just left of the N rightmost proxies, instead of the first public address, and rejects a shorter chain. `X-Forwarded-For: 203.0.113.10, 10.0.0.1, 10.0.0.2` returns `203.0.113.10` with no `proxy_count`, and `10.0.0.1` with `proxy_count=1`.
+
+### Using FastAPI Dependency Injection
+
+```python
+from typing import Annotated
+from fastapi import Depends, FastAPI
+from fastapi_ipware import ClientIpResult, FastAPIIpWare
+
+app = FastAPI()
+ipware = FastAPIIpWare()
+
+
+@app.get("/")
+async def get_ip(client: Annotated[ClientIpResult, Depends(ipware)]):
+    ip, trusted = client
+    return {
+        "ip": str(ip) if ip else None,
+        "trusted": trusted,
+        "is_public": ip.is_global if ip else None,
+    }
+
+
+# Or inject only the IP object or string directly:
+@app.get("/ip-string")
+async def get_ip_string(ip_str: Annotated[str | None, Depends(ipware.get_ip_str)]):
+    return {"ip": ip_str}
+```
+
+### Using Request Directly
+
+```python
+from fastapi import FastAPI, Request
+from fastapi_ipware import FastAPIIpWare
+
+app = FastAPI()
+ipware = FastAPIIpWare()
+
+
+@app.get("/")
+async def get_ip(request: Request):
+    ip, trusted = ipware.get_client_ip_from_request(request)
+    return {"ip": str(ip) if ip else None, "trusted": trusted}
+```
+
+### Using ASGI Middleware
+
+Automatically extract the client IP onto `request.state` for every request:
+
+```python
+from fastapi import FastAPI, Request
+from fastapi_ipware import IpWareMiddleware
+
+app = FastAPI()
+app.add_middleware(IpWareMiddleware)
+
+
+@app.get("/")
+async def get_ip(request: Request):
+    return {
+        "ip": request.state.client_ip_str,
+        "trusted": request.state.ip_trusted,
+    }
+```
+
+Pass a configured resolver when you need one. Omit `strict` to use that resolver's `default_strict`; pass `strict=` to override it.
+
+```python
+from fastapi_ipware import FastAPIIpWare, IpWareMiddleware
+
+ipware = FastAPIIpWare(proxy_count=1, default_strict=True)
+app.add_middleware(IpWareMiddleware, ipware=ipware)
+```
+
+### Custom Header Precedence
+
+Customize which headers are checked and in what order:
+
+```python
+# Prioritize Cloudflare headers
+ipware = FastAPIIpWare(
+    precedence=(
+        "CF-Connecting-IP",
+        "X-Forwarded-For",
+        "X-Real-IP",
+    )
+)
+
+# NGINX configuration
+ipware = FastAPIIpWare(
+    precedence=(
+        "X-Real-IP",
+        "X-Forwarded-For",
+    )
+)
+```
+
+### Proxy Count Validation
+
+Validate that requests pass through the expected number of proxies:
+
+```python
+# Expect exactly 1 proxy (e.g., AWS ALB).
+# default_strict applies to Depends(ipware), dependency(), and IpWareMiddleware.
+ipware = FastAPIIpWare(proxy_count=1, default_strict=True)
+
+# In strict mode, must be exactly 1 proxy
+ip, trusted = ipware.get_client_ip_from_request(request, strict=True)
+
+# In non-strict mode, allow 1 or more proxies
+ip, trusted = ipware.get_client_ip_from_request(request, strict=False)
+```
+
+### Trusted Proxy List
+
+Validate that requests pass through specific trusted proxies (supports IP prefixes, exact IPs, and CIDR networks):
+
+```python
+# Trust specific proxy IP prefixes or CIDR networks
+ipware = FastAPIIpWare(
+    proxy_list=["10.0.", "10.1.", "100.64.0.0/10"]  # AWS internal IPs and CGNAT CIDR
+)
+
+ip, trusted = ipware.get_client_ip_from_request(request)
+
+# trusted=True only if request came through specified proxies
+```
+
+### Combined Validation
+
+Use both proxy count and trusted proxy list:
+
+```python
+# Expect 1 proxy from a specific IP range
+ipware = FastAPIIpWare(proxy_count=1, proxy_list=["10.0."])
+```
+
+### Algorithm Engine Selection
+
+Choose between python-ipware 4.x engines (`auto` / `modern` / `legacy`):
+
+```python
+# Modern engine (default): enhanced header parsing and RFC 7239 support
+ipware = FastAPIIpWare(algorithm="modern")
+
+# Legacy engine: frozen byte-for-byte v3 behavior
+ipware = FastAPIIpWare(algorithm="legacy")
+```
+
+## IP Address Types
+
+The returned IP address object has useful properties:
+
+```python
+ip, _ = ipware.get_client_ip_from_request(request)
+
+if ip:
+    print(f"Is public: {ip.is_global}")
+    print(f"Is private: {ip.is_private}")
+    print(f"Is loopback: {ip.is_loopback}")
+    print(f"Is multicast: {ip.is_multicast}")
+```
+
+python-ipware automatically prefers:
+
+1. Public (global) IPs first
+2. Private IPs second
+3. Loopback IPs last
+
+## License
+
+[MIT License](LICENSE.md)
+
+## Credits
+
+- Built on top of [python-ipware](https://github.com/un33k/python-ipware) by un33k.
+- https://github.com/long2ice/fastapi-limiter/blob/8d179c058fa2aaf98f3450c9026a7300ae2b3bdd/fastapi_limiter/__init__.py#L11
+
+---
+
+*This project was created from [iloveitaly/python-package-template](https://github.com/iloveitaly/python-package-template)*

fastapi_ipware-0.2.0/fastapi_ipware/__init__.py

@@ -0,0 +1,240 @@
+import ipaddress
+from collections.abc import Callable
+from typing import Literal
+
+from python_ipware import IpWare
+from starlette.requests import HTTPConnection
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+from .version import __version__
+
+Algorithm = Literal["auto", "modern", "legacy"]
+IpAddressType = ipaddress.IPv4Address | ipaddress.IPv6Address
+ClientIpResult = tuple[IpAddressType | None, bool]
+
+DEFAULT_PRECEDENCE: tuple[str, ...] = (
+    # Provider-specific headers (highest reliability)
+    "CF-Connecting-IP",  # Cloudflare
+    "True-Client-IP",  # Cloudflare Enterprise, Akamai
+    "Fastly-Client-IP",  # Fastly, Firebase
+    "Fly-Client-IP",  # Fly.io
+    "X-Client-IP",  # Microsoft Azure
+    "X-Azure-ClientIP",  # Azure Front Door
+    "DO-Connecting-IP",  # DigitalOcean App Platform
+    "X-Cluster-Client-IP",  # Rackspace Cloud Load Balancers
+    "X-Appengine-User-IP",  # Google App Engine
+    "X-Envoy-External-Address",  # Envoy / Istio
+    # Generic headers (fallback)
+    "X-Forwarded-For",  # Generic, used by AWS ELB, nginx, etc.
+    "X-Real-IP",  # NGINX
+    "Forwarded-For",  # Plain IP list variant
+    "Forwarded",  # RFC 7239 (for=...;proto=...)
+    "Client-IP",  # Akamai, Cloudflare fallback
+    "REMOTE_ADDR",  # Direct connection fallback
+)
+
+
+class FastAPIIpWare(IpWare):
+    """
+    A FastAPI/Starlette-native wrapper around python-ipware that eliminates
+    the need for WSGI-style header conversion at request time.
+
+    This class accepts natural header names (e.g., "X-Forwarded-For") and
+    handles the conversion to ipware's expected format internally.
+
+    Example:
+        >>> from fastapi_ipware import FastAPIIpWare
+        >>> ipware = FastAPIIpWare()
+        >>> ip, trusted = ipware.get_client_ip_from_request(request)
+
+        >>> # Direct FastAPI route dependency
+        >>> @app.get("/")
+        ... def endpoint(client: ClientIpResult = Depends(ipware)):
+        ...     ip, trusted = client
+    """
+
+    def __init__(
+        self,
+        precedence: tuple[str, ...] | None = None,
+        leftmost: bool = True,
+        proxy_count: int | None = None,
+        proxy_list: list[str] | None = None,
+        algorithm: Algorithm = "auto",
+        default_strict: bool = False,
+    ):
+        """
+        Initialize FastAPIIpWare with optional configuration.
+
+        Args:
+            precedence: Tuple of header names to check in order. Uses natural header
+                       names with dashes (e.g., "X-Forwarded-For", "X-Real-IP").
+                       If None, uses FastAPI-optimized defaults.
+            leftmost: If True, use leftmost IP in comma-separated list (standard).
+                     If False, use rightmost IP (rare legacy configurations).
+            proxy_count: Expected number of proxies between client and server.
+                        Used to validate and extract the correct client IP.
+            proxy_list: List of trusted proxy IP prefixes, complete IPs, or CIDR networks
+                       (e.g., ["10.1.", "198.84.193.157", "100.64.0.0/10"]).
+            algorithm: Algorithm engine to use: "auto" (default, uses modern),
+                      "modern" (v4 enhanced engine), or "legacy" (frozen v3 engine).
+            default_strict: Used whenever strict is omitted: Depends(self),
+                           dependency() with no argument, IpWareMiddleware, and
+                           get_client_ip_from_request.
+        """
+        if precedence is None:
+            precedence = DEFAULT_PRECEDENCE
+
+        # Store FastAPI-style precedence for reference
+        self._fastapi_precedence = precedence
+        self.default_strict = default_strict
+
+        # Expand precedence to support both natural and WSGI formats
+        expanded_precedence: list[str] = []
+        for header in precedence:
+            if header == "REMOTE_ADDR":
+                if "REMOTE_ADDR" not in expanded_precedence:
+                    expanded_precedence.append("REMOTE_ADDR")
+            elif header.startswith("HTTP_"):
+                if header not in expanded_precedence:
+                    expanded_precedence.append(header)
+                non_http = header[5:].replace("_", "-")
+                if non_http not in expanded_precedence:
+                    expanded_precedence.append(non_http)
+            else:
+                if header not in expanded_precedence:
+                    expanded_precedence.append(header)
+                wsgi_form = f"HTTP_{header.upper().replace('-', '_')}"
+                if wsgi_form not in expanded_precedence:
+                    expanded_precedence.append(wsgi_form)
+
+        super().__init__(
+            tuple(expanded_precedence),
+            leftmost=leftmost,
+            proxy_count=proxy_count,
+            proxy_list=proxy_list,
+            algorithm=algorithm,
+        )
+
+    @property
+    def precedence(self) -> tuple[str, ...]:
+        """Header precedence tuple from the active engine."""
+        return getattr(self.engine, "precedence", ())
+
+    @property
+    def leftmost(self) -> bool:
+        """Leftmost setting from the active engine."""
+        return getattr(self.engine, "leftmost", True)
+
+    @property
+    def proxy_count(self) -> int | None:
+        """Proxy count setting from the active engine."""
+        return getattr(self.engine, "proxy_count", None)
+
+    @property
+    def proxy_list(self) -> list[str]:
+        """Proxy list setting from the active engine."""
+        return getattr(self.engine, "proxy_list", [])
+
+    def __call__(self, request: HTTPConnection) -> ClientIpResult:
+        """FastAPI route dependency injection entrypoint."""
+        return self.get_client_ip_from_request(request, strict=self.default_strict)
+
+    def dependency(
+        self, strict: bool | None = None
+    ) -> Callable[[HTTPConnection], ClientIpResult]:
+        """Return a FastAPI dependency. An omitted strict flag uses default_strict."""
+
+        def _dep(request: HTTPConnection) -> ClientIpResult:
+            return self.get_client_ip_from_request(request, strict=strict)
+
+        return _dep
+
+    def get_ip(self, request: HTTPConnection) -> IpAddressType | None:
+        """Return only the client IP address (or None if unresolvable)."""
+        ip, _ = self.get_client_ip_from_request(request, strict=self.default_strict)
+        return ip
+
+    def get_ip_str(self, request: HTTPConnection) -> str | None:
+        """Return the client IP address as a string (or None if unresolvable)."""
+        ip = self.get_ip(request)
+        return str(ip) if ip is not None else None
+
+    def get_client_ip_from_request(
+        self, request: HTTPConnection, strict: bool | None = None
+    ) -> ClientIpResult:
+        """
+        Get client IP address from a FastAPI/Starlette Request or WebSocket connection.
+
+        Args:
+            request: FastAPI/Starlette Request or HTTPConnection object
+            strict: If True, enforce exact proxy count/list match.
+                   If False, allow more proxies than specified.
+                   If None, use self.default_strict.
+
+        Returns:
+            Tuple of (ip_address, trusted_route) where:
+                - ip_address: IPv4Address or IPv6Address object (or None if not found)
+                - trusted_route: True if request came through trusted proxies, False otherwise
+        """
+        if strict is None:
+            strict = self.default_strict
+
+        # Populate both WSGI-style headers and original Starlette headers
+        meta = {
+            f"HTTP_{name.upper().replace('-', '_')}": value
+            for name, value in request.headers.items()
+        }
+        for name, value in request.headers.items():
+            meta[name] = value
+
+        if request.client:
+            # Map Starlette's connection info to REMOTE_ADDR fallback
+            meta["REMOTE_ADDR"] = request.client.host
+
+        return self.get_client_ip(meta, strict=strict)
+
+
+class IpWareMiddleware:
+    """
+    ASGI middleware that resolves the client IP address and attaches it to request state:
+      - `request.state.client_ip`: IPv4Address | IPv6Address | None
+      - `request.state.ip_trusted`: bool
+      - `request.state.client_ip_str`: str | None
+
+    Pass `ipware` to use a configured resolver. `strict` overrides that
+    resolver's `default_strict`; omit it to use `default_strict`.
+    """
+
+    def __init__(
+        self,
+        app: ASGIApp,
+        ipware: FastAPIIpWare | None = None,
+        strict: bool | None = None,
+    ) -> None:
+        self.app = app
+        self.ipware = ipware if ipware is not None else FastAPIIpWare()
+        self.strict = strict
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] in ("http", "websocket"):
+            conn = HTTPConnection(scope)
+            ip, trusted = self.ipware.get_client_ip_from_request(
+                conn, strict=self.strict
+            )
+            scope.setdefault("state", {})
+            scope["state"]["client_ip"] = ip
+            scope["state"]["ip_trusted"] = trusted
+            scope["state"]["client_ip_str"] = str(ip) if ip is not None else None
+
+        await self.app(scope, receive, send)
+
+
+__all__ = [
+    "DEFAULT_PRECEDENCE",
+    "Algorithm",
+    "ClientIpResult",
+    "FastAPIIpWare",
+    "IpAddressType",
+    "IpWareMiddleware",
+    "__version__",
+]