http3x 0.1.0__py3-none-any.whl

http3x/__init__.py

@@ -0,0 +1,9 @@
+"""
+HTTP3X - A modern async server framework for HTTP/3 and WebTransport over QUIC.
+
+This module exports the main application classes for HTTP3X.
+"""
+
+from ._core.base import (
+    App, AppConfiguration
+)

http3x/_core/base.py

@@ -0,0 +1,261 @@
+"""
+HTTP3X core base module.
+
+This module contains the core classes for HTTP3X, including:
+- DropQueue: A queue that drops items when full
+- Signals: Signal classes for internal communication
+- QuicConnection: QUIC connection protocol implementation
+- WebTransportSessionRoutes: WebTransport session route management
+- AppConfiguration: Application configuration class
+- App: Main application class
+"""
+
+from __future__ import annotations
+import asyncio, logging, re
+from pathlib import Path
+from os.path import abspath
+
+from aioquic.asyncio import QuicConnectionProtocol, serve
+from aioquic.h3.connection import H3_ALPN, H3Connection
+from aioquic.h3.events import (
+    DatagramReceived,
+    H3Event,
+    HeadersReceived,
+    WebTransportStreamDataReceived,
+)
+from aioquic.quic.configuration import QuicConfiguration
+from aioquic.quic.events import ProtocolNegotiated, QuicEvent
+from aioquic.quic.events import ConnectionTerminated
+
+logging.getLogger("aioquic").setLevel(logging.WARNING)
+logging.getLogger("quic").setLevel(logging.WARNING)
+logging.getLogger("aioquic.asyncio").setLevel(logging.WARNING)
+logging.getLogger("aioquic.asyncio.server").setLevel(logging.WARNING)
+
+
+class DropQueue(asyncio.Queue):
+    """
+    A queue that drops items when full.
+    
+    This is used to prevent queue overflow in high-traffic scenarios.
+    """
+    def put_nowait(self, item):
+        """
+        Put an item into the queue without waiting.
+        
+        If the queue is full, the item is dropped.
+        
+        Args:
+            item: The item to put into the queue
+        """
+        try:
+            asyncio.Queue.put_nowait(self, item)
+        except asyncio.queues.QueueFull:
+            pass
+
+
+class Signals:
+    """
+    Signal classes for internal communication.
+    """
+    class Ended: 
+        """
+        Signal indicating that a session or stream has ended.
+        """
+        ...
+
+
+class QuicConnection(QuicConnectionProtocol):
+    """
+    QUIC connection protocol implementation for HTTP3X.
+    
+    This class handles QUIC events and manages WebTransport sessions.
+    """
+    _app: 'App'
+
+    def __init__(self, *args, **kwargs):
+        """
+        Initialize a QuicConnection.
+        
+        Args:
+            *args: Positional arguments for QuicConnectionProtocol
+            **kwargs: Keyword arguments for QuicConnectionProtocol
+        """
+        QuicConnectionProtocol.__init__(self, *args, **kwargs)
+        self._handlers: dict[int, WebTransportSession] = {}
+        self._conn: H3Connection = None
+
+    def quic_event_received(self, event: QuicEvent):
+        """
+        Handle QUIC events.
+        
+        Args:
+            event: The QUIC event to handle
+        """
+        try:
+            if isinstance(event, ProtocolNegotiated) and event.alpn_protocol in H3_ALPN:
+                self._conn = H3Connection(self._quic, enable_webtransport=True)
+            elif isinstance(event, ConnectionTerminated):
+                for key, handler in list(self._handlers.items()):
+                    handler._event_msgs.put_nowait(Signals.Ended)
+                    self._handlers.pop(key, None)
+            if self._conn is not None:
+                for event in self._conn.handle_event(event):
+                    event: H3Event
+                    try:
+                        if isinstance(event, HeadersReceived):
+                            if (session_id := event.stream_id) in self._handlers: return
+                            if not isinstance(self._conn, H3Connection): return
+                            headers = dict(event.headers)
+                            if not (headers[b':method'] == b"CONNECT" and headers[b':protocol'] == b"webtransport"): return
+                            remote_addr = self._conn._quic._network_paths[0].addr[:2]
+                            request_path = headers[b':path'].decode('utf-8')
+                            path = request_path.split('?', 1)[0]
+                            for pattern, Handler in self._app.wt.route_patterns.values():
+                                if m := pattern.match(path):
+                                    self._handlers[session_id] = handler = Handler(
+                                        session_id = session_id,
+                                        connection = self,
+                                        remote_addr = remote_addr,
+                                        headers = event.headers,
+                                        request_path = request_path,
+                                        path = path,
+                                        path_params = m.groups(),
+                                    )
+                                    asyncio.create_task(handler._run())
+                                    break
+                        elif isinstance(event, DatagramReceived):
+                            self._handlers[event.stream_id]._datagram_msgs.put_nowait(event.data)
+                        elif isinstance(event, WebTransportStreamDataReceived):
+                            self._handlers[event.session_id]._event_msgs.put_nowait(event)
+                    except:
+                        pass
+        except Exception as e:
+            logging.exception(f"Error in quic_event_received: {e}")
+
+
+class WebTransportSessionRoutes:
+    """
+    WebTransport session route management.
+    
+    This class manages routes for WebTransport sessions.
+    """
+    def __init__(self):
+        """
+        Initialize WebTransportSessionRoutes.
+        """
+        self.route_patterns: dict[
+            str,
+            tuple[
+                re.Pattern,
+                type[WebTransportSession]
+            ]
+        ] = {}
+ 
+    def add(self, route_pattern: str, handler: type[WebTransportSession]):
+        """
+        Add a WebTransport session route.
+        
+        Args:
+            route_pattern: The route pattern to match
+            handler: The WebTransportSession class to use for matching routes
+        """
+        self.route_patterns[route_pattern] = re.compile(route_pattern), handler
+
+
+class AppConfiguration(QuicConfiguration): 
+    """
+    Application configuration class.
+    
+    This class extends QuicConfiguration for HTTP3X applications.
+    """
+    ...
+
+
+class App:
+    """
+    Main application class for HTTP3X.
+    
+    This class manages WebTransport session routes and server lifecycle.
+    """
+    def __init__(self):
+        """
+        Initialize an App instance.
+        """
+        self.wt = WebTransportSessionRoutes()
+    
+    async def async_run(
+                        self,
+                        host,
+                        port: int,
+                        certfile: str|Path,
+                        keyfile: str|Path,
+                        *,
+                        retry: bool=False,
+                        configuration: AppConfiguration|None=None,
+                        ) -> None:
+        """
+        Run the application asynchronously.
+        
+        Args:
+            host: The host to listen on
+            port: The port to listen on
+            certfile: Path to the SSL certificate file
+            keyfile: Path to the SSL key file
+            retry: Whether to enable QUIC retry
+            configuration: Application configuration
+        """
+        
+        class QuicConnection_(QuicConnection):
+            _app = self
+        
+        configuration = configuration or AppConfiguration(
+            alpn_protocols=["h3"],
+            is_client=False,
+        )
+        configuration.is_client = False
+        configuration.load_cert_chain(abspath(str(certfile)), abspath(str(keyfile)))
+        self.server = await serve(
+            host = host,
+            port = port,
+            configuration = configuration,
+            create_protocol = QuicConnection_,
+            retry = retry,
+        )
+        print(f"http3x running on https://{host}:{port}")
+    
+    def run(
+            self,
+            host,
+            port: int,
+            certfile: str|Path,
+            keyfile: str|Path,
+            *,
+            retry: bool=False,
+            configuration: AppConfiguration|None=None,
+            ) -> None:
+        """
+        Run the application synchronously.
+        
+        Args:
+            host: The host to listen on
+            port: The port to listen on
+            certfile: Path to the SSL certificate file
+            keyfile: Path to the SSL key file
+            retry: Whether to enable QUIC retry
+            configuration: Application configuration
+        """
+        
+        async def run_forever():
+            await self.async_run(host, port, certfile, keyfile, retry=retry, configuration=configuration)
+            await asyncio.Event().wait()
+        asyncio.run(run_forever())
+    
+    def close(self):
+        """
+        Close the server.
+        """
+        self.server.close()
+        print(f"Http3x server have closed")
+
+from .webtransport import WebTransportSession

http3x/_core/webtransport.py

@@ -0,0 +1,283 @@
+"""
+HTTP3X WebTransport module.
+
+This module contains WebTransport session and stream classes for HTTP3X, including:
+- WebTransportStream: Represents a WebTransport stream
+- WebTransportSession: Represents a WebTransport session
+"""
+
+from __future__ import annotations
+import asyncio, logging
+
+from aioquic.h3.events import WebTransportStreamDataReceived
+
+from .base import Signals, QuicConnection, DropQueue
+
+
+class WebTransportStream:
+    """
+    Represents a WebTransport stream.
+    
+    This class provides methods to send and receive data over a WebTransport stream.
+    """
+    def __init__(self, session: WebTransportSession, stream_id: int):
+        """
+        Initialize a WebTransportStream.
+        
+        Args:
+            session: The WebTransportSession this stream belongs to
+            stream_id: The stream ID
+        """
+        self.session = session
+        self.stream_id = stream_id
+        self._stream_msgs: asyncio.Queue[bytes]|DropQueue = asyncio.Queue()
+    
+    async def send(self, data: bytes, end_stream: bool=False, *, flush=True):
+        """
+        Send data over the stream.
+        
+        Args:
+            data: The data to send
+            end_stream: Whether to end the stream after sending
+            flush: Whether to flush the connection after sending
+        """
+        self.session._conn._quic.send_stream_data(stream_id=self.stream_id, data=data, end_stream=end_stream)
+        if flush:
+            await self.session.flush()
+    
+    async def __aiter__(self):
+        """
+        Asynchronous iterator for receiving data from the stream.
+        
+        Yields:
+            bytes: The received data
+        """
+        try:
+            while True:
+                data = await self._stream_msgs.get()
+                if type(data) is bytes:
+                    yield data
+                elif data is Signals.Ended:
+                    break
+        except Exception as e:
+            logging.exception(f"Error in WebTransportStream.__aiter__: {e}")
+            self._stream_msgs = DropQueue(maxsize=1)
+        else:
+            self.session._streams.pop(self.stream_id, None)
+
+
+class WebTransportSession:
+    """
+    Represents a WebTransport session.
+    
+    This class manages WebTransport streams and handles session lifecycle.
+    """
+    def __init__(
+        self,
+        *,
+        session_id: int,
+        connection: QuicConnection,
+        remote_addr: tuple[str, int],
+        headers: list[tuple[bytes, bytes]],
+        request_path: str,
+        path: str,
+        path_params: tuple[str],
+    ) -> None:
+        """
+        Initialize a WebTransportSession.
+        
+        Args:
+            session_id: The session ID
+            connection: The QuicConnection this session belongs to
+            remote_addr: The remote address (host, port)
+            headers: The request headers
+            request_path: The full request path
+            path: The path without query parameters
+            path_params: The path parameters
+        """
+        self.session_id = session_id
+        self.connection = connection
+        self.remote_addr = remote_addr
+        self.headers = headers
+        self.request_path = request_path
+        self.path = path
+        self.path_params = path_params
+
+        self.accepted = False
+        self.closed = False
+        self._closed_event = asyncio.Event()
+        self._event_msgs: asyncio.Queue|DropQueue = asyncio.Queue()
+        self._datagram_msgs: asyncio.Queue|DropQueue = asyncio.Queue()
+        self._conn = connection._conn
+        self._streams: dict[int, WebTransportStream] = {}
+    
+    async def flush(self):
+        """
+        Flush the connection.
+        
+        This sends any pending data over the connection.
+        """
+        self.connection.transmit()
+    
+    async def authorize(self) -> bool:
+        """
+        Authorize the session.
+        
+        Returns:
+            bool: True if authorized, False otherwise
+            
+        Example:
+            ```python
+            if dict(self.headers).get(b'authorization') == b'Bearer my-token':
+                return True
+            else:
+                return False
+            ```
+        """
+        return True
+    
+    async def on_connect(self):
+        """
+        Called when the session is connected.
+        
+        This method can be overridden to handle connection events.
+        """
+        ...
+
+    async def on_close(self):
+        """
+        Called when the session is closed.
+        
+        This method can be overridden to handle close events.
+        """
+        ...
+    
+    async def on_stream(self, stream: WebTransportStream):
+        """
+        Called when a new stream is created.
+        
+        This method can be overridden to handle stream events.
+        
+        Args:
+            stream: The new WebTransportStream
+        """
+        async for data in stream:
+            ...
+    
+    async def on_datagram(self, data: bytes):
+        """
+        Called when a datagram is received.
+        
+        This method can be overridden to handle datagram events.
+        
+        Args:
+            data: The received datagram
+        """
+        ...
+
+    async def request_close(self):
+        """
+        Request to close the session.
+        """
+        self._event_msgs.put_nowait(Signals.Ended)
+    
+    async def wait_closed(self):
+        """
+        Wait for the session to close.
+        """
+        await self._closed_event.wait()
+    
+    async def send_datagram(self, data: bytes, *, flush=True):
+        """
+        Send a datagram.
+        
+        Args:
+            data: The datagram to send
+            flush: Whether to flush the connection after sending
+        """
+        self._conn.send_datagram(stream_id=self.session_id, data=data)
+        if flush:
+            await self.flush()
+    
+    async def create_stream(self) -> WebTransportStream:
+        """
+        Create a new bidirectional stream.
+        
+        Returns:
+            WebTransportStream: The new stream
+        """
+        stream_id = self._conn.create_webtransport_stream(session_id=self.session_id, bidirectional=True)
+        stream = self._streams[stream_id] = WebTransportStream(self, stream_id)
+        asyncio.create_task(self.on_stream(stream))
+        return stream
+    
+    async def _run(self):
+        """
+        Run the session.
+        
+        This method handles session lifecycle and events.
+        """
+        try:
+            self.accepted = bool(await self.authorize())
+            if self.accepted:
+                try:
+                    self._conn.send_headers(stream_id=self.session_id, headers=[(b":status", b"200")])
+                    await self.flush()
+                    await self.on_connect()
+                    asyncio.create_task(self._on_datagram_task())
+                    while True:
+                        event = await self._event_msgs.get()
+                        if isinstance(event, WebTransportStreamDataReceived):
+                            stream_id = event.stream_id
+                            stream = self._streams.get(stream_id)
+                            if not stream:
+                                stream = self._streams[stream_id] = WebTransportStream(self, stream_id)
+                                asyncio.create_task(self.on_stream(stream))
+                            stream._stream_msgs.put_nowait(event.data)
+                            if event.stream_ended:
+                                stream._stream_msgs.put_nowait(Signals.Ended)
+                        elif event is Signals.Ended:
+                            break
+                finally:
+                    self._event_msgs = DropQueue(maxsize=1)
+                    self._datagram_msgs.put_nowait(Signals.Ended)
+                    for stream_id, stream in list(self._streams.items()):
+                        stream._stream_msgs.put_nowait(Signals.Ended)
+                        self._streams.pop(stream_id, None)
+                    try:
+                        await self.flush()
+                    except Exception as e:
+                        logging.exception(f"Error flushing connection: {e}")
+                    self.closed = True
+                    self._closed_event.set()
+                    await self.wait_closed()
+                    await self.on_close()
+            else:
+                try:
+                    self._conn.send_headers(stream_id=self.session_id, headers=[(b":status", b"403")])
+                    self._conn.send_data(stream_id=self.session_id, data=b"", end_stream=True)
+                    await self.flush()
+                finally:
+                    self.closed = True
+                    self._closed_event.set()
+        finally:
+            self.closed = True
+            self._closed_event.set()
+            self.connection._handlers.pop(self.session_id, None)
+
+    async def _on_datagram_task(self):
+        """
+        Handle datagram events.
+        
+        This method runs in a separate task to handle datagrams.
+        """
+        try:
+            while True:
+                data = await self._datagram_msgs.get()
+                if type(data) is bytes:
+                    await self.on_datagram(data)
+                elif data is Signals.Ended:
+                    break
+        except Exception as e:
+            logging.exception(f"Error in _on_datagram_task: {e}")
+            self._datagram_msgs = DropQueue(maxsize=1)

http3x/wt.py

@@ -0,0 +1,15 @@
+"""
+WebTransport module for HTTP3X.
+
+This module provides WebTransport session and stream classes for HTTP3X.
+"""
+
+from ._core.webtransport import (
+    WebTransportSession, WebTransportStream
+)
+
+Session = WebTransportSession
+"""Alias for WebTransportSession"""
+
+Stream = WebTransportStream
+"""Alias for WebTransportStream"""

http3x-0.1.0.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: http3x
+Version: 0.1.0
+Summary: A modern async server framework for HTTP/3 and WebTransport over QUIC.
+Author-email: 许灿标 <canbiaoxu@outlook.com>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: Apache Software License
+License-File: LICENSE
+Requires-Dist: aioquic
+Requires-Dist: wsproto
+Requires-Dist: starlette
+Requires-Dist: uvicorn
+Requires-Dist: httpx
+Project-URL: Documentation, https://github.com/canbiaoxu/http3x
+Project-URL: Repository, https://github.com/canbiaoxu/http3x
+
+# HTTP3X
+
+> A WebSocket replacement built on HTTP/3 and QUIC.
+
+Async Python server framework for HTTP/3 + WebTransport (QUIC).
+
+> What WebSocket would look like if it was designed today.
+
+## 🚀 Quick Example
+
+```python
+from http3x import App
+from http3x.wt import Session
+
+app = App()
+
+class Echo(Session):
+    async def on_stream(self, stream):
+        async for data in stream:
+            await stream.send(data)
+
+app.wt.add("/echo", Echo)
+app.run(host='::', port=4433, certfile="cert.pem", keyfile="key.pem")
+```
+
+## Installation
+
+```bash
+pip install http3x
+```
+
+## 🚀 Live Demo
+
+Streaming AI-style responses over HTTP/3 (WebTransport):
+
+```
+You: hello
+
+AI:
+h
+he
+hel
+hell
+hello 👋
+```
+
+**This is NOT WebSocket.**  
+**This is native HTTP/3 streaming over QUIC.**
+
+![HTTP3X AI Streaming Demo](https://raw.githubusercontent.com/canbiaoxu/http3x/main/demo/wt_demo.png)
+
+See [demo/wt_demo.py](https://github.com/canbiaoxu/http3x/blob/main/demo/wt_demo.py) and [demo/wt_demo.html](https://github.com/canbiaoxu/http3x/blob/main/demo/wt_demo.html) for the complete example.
+
+## ⚡ Why not WebSocket?
+
+| Feature | WebSocket | http3x |
+|---------|-----------|--------|
+| Protocol | TCP | QUIC (HTTP/3) |
+| Streams | Single stream | Multiplexed streams |
+| Datagram | No support | Built-in datagram |
+| Head-of-line blocking | Yes | No |
+
+## Features
+
+- HTTP/3 server (QUIC-based)
+- WebTransport (stream + datagram)
+- Multiplexed streams (no head-of-line blocking)
+- Async/await API
+- Built on aioquic
+
+## Documentation
+
+- [WebTransport Guide](https://github.com/canbiaoxu/http3x/blob/main/docs/webtransport.md) - Complete documentation for WebTransport functionality
+
+More docs coming soon.
+
+## Project Links
+
+- **Source Code**: [GitHub Repository](https://github.com/canbiaoxu/http3x)
+- **Documentation**: [https://github.com/canbiaoxu/http3x](https://github.com/canbiaoxu/http3x)
+- **PyPI**: [http3x](https://pypi.org/project/http3x)
+- **Contributors**: [GitHub Contributors](https://github.com/canbiaoxu/http3x/graphs/contributors)
+
+## Contributing
+
+Contributions are welcome! Please visit the [GitHub repository](https://github.com/canbiaoxu/http3x) to contribute code, report issues, or suggest features.
+
+## License
+
+This project is licensed under the Apache License 2.0. See the [LICENSE](https://github.com/canbiaoxu/http3x/blob/main/LICENSE) file for details.
+

http3x-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+http3x/__init__.py,sha256=OtWblxoDf2wOVgOBPer7BbP3Yarm1xXVrE0TBgQxvOc,212
+http3x/h3.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+http3x/wt.py,sha256=lwUYXk0QxDMFuOM_bJ9Dc1MCeXtjaU35FWSe5dxBJ94,341
+http3x/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+http3x/_core/base.py,sha256=Tr7PbtDpi39aaG1JeMSEmnk8dfzyTn4LXfhXRl_h5Uc,9190
+http3x/_core/http3.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+http3x/_core/webtransport.py,sha256=cAJSFYun6uXBp5eRFhZv3SJUDhA4jbi-8DDPjAU0iQY,9724
+http3x-0.1.0.dist-info/licenses/LICENSE,sha256=-ccY58FIZ7VQUjA9GgwNTZdS44s3kNyi41fxOogLxIY,10948
+http3x-0.1.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+http3x-0.1.0.dist-info/METADATA,sha256=XKV6OIfiLdzMw44TwXusYynRht--c1HiixtYn7LtC5c,2939
+http3x-0.1.0.dist-info/RECORD,,

http3x-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any

http3x-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,190 @@
+Copyright (c) 2026 Canbiao Xu (许灿标) and contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS