diff options
Diffstat (limited to 'python-fastapi-websocket-rpc.spec')
| -rw-r--r-- | python-fastapi-websocket-rpc.spec | 554 |
1 files changed, 554 insertions, 0 deletions
diff --git a/python-fastapi-websocket-rpc.spec b/python-fastapi-websocket-rpc.spec new file mode 100644 index 0000000..3d8b4a9 --- /dev/null +++ b/python-fastapi-websocket-rpc.spec @@ -0,0 +1,554 @@ +%global _empty_manifest_terminate_build 0 +Name: python-fastapi-websocket-rpc +Version: 0.1.24 +Release: 1 +Summary: A fast and durable bidirectional JSON RPC channel over Websockets and FastApi. +License: MIT License +URL: https://github.com/permitio/fastapi_websocket_rpc +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/ca/8c/0dfd344f8fc955b7e363a97c602f193b62b60276a87022d409942e7dbbe2/fastapi_websocket_rpc-0.1.24.tar.gz +BuildArch: noarch + +Requires: python3-fastapi +Requires: python3-pydantic +Requires: python3-uvicorn +Requires: python3-websockets +Requires: python3-tenacity + +%description +<p align="center"> +<img src="https://i.ibb.co/m8jL6Zd/RPC.png" alt="RPC" border="0" width="50%" /> +</p> + +# + +# ⚡ FASTAPI Websocket RPC +RPC over Websockets made easy, robust, and production ready + +<a href="https://github.com/permitio/fastapi_websocket_rpc/actions?query=workflow%3ATests" target="_blank"> + <img src="https://github.com/permitio/fastapi_websocket_rpc/workflows/Tests/badge.svg" alt="Tests"> +</a> + +<a href="https://pypi.org/project/fastapi-websocket-rpc/" target="_blank"> + <img src="https://img.shields.io/pypi/v/fastapi-websocket-rpc?color=%2331C654&label=PyPi%20package" alt="Package"> +</a> + +<a href="https://pepy.tech/project/fastapi-websocket-rpc" target="_blank"> + <img src="https://static.pepy.tech/personalized-badge/fastapi-websocket-rpc?period=total&units=international_system&left_color=black&right_color=blue&left_text=Downloads" alt="Downloads"> +</a> + +A fast and durable bidirectional JSON RPC channel over Websockets. +The easiest way to create a live async channel between two nodes via Python (or other clients). + +- Both server and clients can easily expose Python methods that can be called by the other side. +Method return values are sent back as RPC responses, which the other side can wait on. +- Remote methods are easily called via the ```.other.method()``` wrapper +- Connections are kept alive with a configurable retry mechanism (using Tenacity) + +- As seen at <a href="https://www.youtube.com/watch?v=KP7tPeKhT3o" target="_blank">PyCon IL 2021</a> and <a href="https://www.youtube.com/watch?v=IuMZVWEUvGs" target="_blank">EuroPython 2021</a> + + +Supports and tested on Python >= 3.7 +## Installation 🛠️ +``` +pip install fastapi_websocket_rpc +``` + + +## RPC call example: + +Say the server exposes an "add" method, e.g. : +```python +class RpcCalculator(RpcMethodsBase): + async def add(self, a, b): + return a + b +``` +Calling it is as easy as calling the method under the client's "other" property: +```python +response = await client.other.add(a=1,b=2) +print(response.result) # 3 +``` +getting the response with the return value. + + + + +## Usage example: + +### Server: +```python +import uvicorn +from fastapi import FastAPI +from fastapi_websocket_rpc import RpcMethodsBase, WebsocketRPCEndpoint + +# Methods to expose to the clients +class ConcatServer(RpcMethodsBase): + async def concat(self, a="", b=""): + return a + b + +# Init the FAST-API app +app = FastAPI() +# Create an endpoint and load it with the methods to expose +endpoint = WebsocketRPCEndpoint(ConcatServer()) +# add the endpoint to the app +endpoint.register_route(app, "/ws") + +# Start the server itself +uvicorn.run(app, host="0.0.0.0", port=9000) +``` +### Client +```python +import asyncio +from fastapi_websocket_rpc import RpcMethodsBase, WebSocketRpcClient + +async def run_client(uri): + async with WebSocketRpcClient(uri, RpcMethodsBase()) as client: + # call concat on the other side + response = await client.other.concat(a="hello", b=" world") + # print result + print(response.result) # will print "hello world" + +# run the client until it completes interaction with server +asyncio.get_event_loop().run_until_complete( + run_client("ws://localhost:9000/ws") +) +``` + +See the [examples](/examples) and [tests](/tests) folders for more server and client examples + + +## Server calling client example: +- Clients can call ```client.other.method()``` + - which is a shortcut for ```channel.other.method()``` +- Servers also get the channel object and can call remote methods via ```channel.other.method()``` +- See the [bidirectional call example](examples/bidirectional_server_example.py) for calling client from server and server events (e.g. ```on_connect```). + + +## What can I do with this? +Websockets are ideal to create bi-directional realtime connections over the web. + - Push updates + - Remote control mechanism + - Pub / Sub (see [fastapi_websocket_pubsub](https://github.com/permitio/fastapi_websocket_pubsub)) + - Trigger events (see "tests/trigger_flow_test.py") + - Node negotiations (see "tests/advanced_rpc_test.py :: test_recursive_rpc_calls") + + +## Concepts +- [RpcChannel](fastapi_websocket_rpc/rpc_channel.py) - implements the RPC-protocol over the websocket + - Sending RpcRequests per method call + - Creating promises to track them (via unique call ids), and allow waiting for responses + - Executing methods on the remote side and serializing return values as + - Receiving RpcResponses and delivering them to waiting callers +- [RpcMethods](fastapi_websocket_rpc/rpc_methods.py) - classes passed to both client and server-endpoint inits to expose callable methods to the other side. + - Simply derive from RpcMethodsBase and add your own async methods + - Note currently only key-word arguments are supported + - Checkout RpcUtilityMethods for example methods, which are also useful debugging utilities + + +- Foundations: + + - Based on [asyncio](https://docs.python.org/3/library/asyncio.html) for the power of Python coroutines + + - Server Endpoint: + - Based on [FAST-API](https://github.com/tiangolo/fastapi): enjoy all the benefits of a full ASGI platform, including Async-io and dependency injections (for example to authenticate connections) + + - Based on [Pydnatic](https://pydantic-docs.helpmanual.io/): easily serialize structured data as part of RPC requests and responses (see 'tests/basic_rpc_test.py :: test_structured_response' for an example) + + - Client : + - Based on [Tenacity](https://tenacity.readthedocs.io/en/latest/index.html): allowing configurable retries to keep to connection alive + - see WebSocketRpcClient.__init__'s retry_config + - Based on python [websockets](https://websockets.readthedocs.io/en/stable/intro.html) - a more comprehensive client than the one offered by Fast-api + +## Logging +fastapi-websocket-rpc provides a helper logging module to control how it produces logs for you. +See [fastapi_websocket_rpc/logger.py](fastapi_websocket_rpc/logger.py). +Use ```logging_config.set_mode``` or the 'WS_RPC_LOGGING' environment variable to choose the logging method you prefer or override completely via default logging config. + +example: +```python +# set RPC to log like UVICORN +from fastapi_websocket_rpc.logger import logging_config, LoggingModes +logging_config.set_mode(LoggingModes.UVICORN) +``` + +## Pull requests - welcome! +- Please include tests for new features + + + + +%package -n python3-fastapi-websocket-rpc +Summary: A fast and durable bidirectional JSON RPC channel over Websockets and FastApi. +Provides: python-fastapi-websocket-rpc +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-fastapi-websocket-rpc +<p align="center"> +<img src="https://i.ibb.co/m8jL6Zd/RPC.png" alt="RPC" border="0" width="50%" /> +</p> + +# + +# ⚡ FASTAPI Websocket RPC +RPC over Websockets made easy, robust, and production ready + +<a href="https://github.com/permitio/fastapi_websocket_rpc/actions?query=workflow%3ATests" target="_blank"> + <img src="https://github.com/permitio/fastapi_websocket_rpc/workflows/Tests/badge.svg" alt="Tests"> +</a> + +<a href="https://pypi.org/project/fastapi-websocket-rpc/" target="_blank"> + <img src="https://img.shields.io/pypi/v/fastapi-websocket-rpc?color=%2331C654&label=PyPi%20package" alt="Package"> +</a> + +<a href="https://pepy.tech/project/fastapi-websocket-rpc" target="_blank"> + <img src="https://static.pepy.tech/personalized-badge/fastapi-websocket-rpc?period=total&units=international_system&left_color=black&right_color=blue&left_text=Downloads" alt="Downloads"> +</a> + +A fast and durable bidirectional JSON RPC channel over Websockets. +The easiest way to create a live async channel between two nodes via Python (or other clients). + +- Both server and clients can easily expose Python methods that can be called by the other side. +Method return values are sent back as RPC responses, which the other side can wait on. +- Remote methods are easily called via the ```.other.method()``` wrapper +- Connections are kept alive with a configurable retry mechanism (using Tenacity) + +- As seen at <a href="https://www.youtube.com/watch?v=KP7tPeKhT3o" target="_blank">PyCon IL 2021</a> and <a href="https://www.youtube.com/watch?v=IuMZVWEUvGs" target="_blank">EuroPython 2021</a> + + +Supports and tested on Python >= 3.7 +## Installation 🛠️ +``` +pip install fastapi_websocket_rpc +``` + + +## RPC call example: + +Say the server exposes an "add" method, e.g. : +```python +class RpcCalculator(RpcMethodsBase): + async def add(self, a, b): + return a + b +``` +Calling it is as easy as calling the method under the client's "other" property: +```python +response = await client.other.add(a=1,b=2) +print(response.result) # 3 +``` +getting the response with the return value. + + + + +## Usage example: + +### Server: +```python +import uvicorn +from fastapi import FastAPI +from fastapi_websocket_rpc import RpcMethodsBase, WebsocketRPCEndpoint + +# Methods to expose to the clients +class ConcatServer(RpcMethodsBase): + async def concat(self, a="", b=""): + return a + b + +# Init the FAST-API app +app = FastAPI() +# Create an endpoint and load it with the methods to expose +endpoint = WebsocketRPCEndpoint(ConcatServer()) +# add the endpoint to the app +endpoint.register_route(app, "/ws") + +# Start the server itself +uvicorn.run(app, host="0.0.0.0", port=9000) +``` +### Client +```python +import asyncio +from fastapi_websocket_rpc import RpcMethodsBase, WebSocketRpcClient + +async def run_client(uri): + async with WebSocketRpcClient(uri, RpcMethodsBase()) as client: + # call concat on the other side + response = await client.other.concat(a="hello", b=" world") + # print result + print(response.result) # will print "hello world" + +# run the client until it completes interaction with server +asyncio.get_event_loop().run_until_complete( + run_client("ws://localhost:9000/ws") +) +``` + +See the [examples](/examples) and [tests](/tests) folders for more server and client examples + + +## Server calling client example: +- Clients can call ```client.other.method()``` + - which is a shortcut for ```channel.other.method()``` +- Servers also get the channel object and can call remote methods via ```channel.other.method()``` +- See the [bidirectional call example](examples/bidirectional_server_example.py) for calling client from server and server events (e.g. ```on_connect```). + + +## What can I do with this? +Websockets are ideal to create bi-directional realtime connections over the web. + - Push updates + - Remote control mechanism + - Pub / Sub (see [fastapi_websocket_pubsub](https://github.com/permitio/fastapi_websocket_pubsub)) + - Trigger events (see "tests/trigger_flow_test.py") + - Node negotiations (see "tests/advanced_rpc_test.py :: test_recursive_rpc_calls") + + +## Concepts +- [RpcChannel](fastapi_websocket_rpc/rpc_channel.py) - implements the RPC-protocol over the websocket + - Sending RpcRequests per method call + - Creating promises to track them (via unique call ids), and allow waiting for responses + - Executing methods on the remote side and serializing return values as + - Receiving RpcResponses and delivering them to waiting callers +- [RpcMethods](fastapi_websocket_rpc/rpc_methods.py) - classes passed to both client and server-endpoint inits to expose callable methods to the other side. + - Simply derive from RpcMethodsBase and add your own async methods + - Note currently only key-word arguments are supported + - Checkout RpcUtilityMethods for example methods, which are also useful debugging utilities + + +- Foundations: + + - Based on [asyncio](https://docs.python.org/3/library/asyncio.html) for the power of Python coroutines + + - Server Endpoint: + - Based on [FAST-API](https://github.com/tiangolo/fastapi): enjoy all the benefits of a full ASGI platform, including Async-io and dependency injections (for example to authenticate connections) + + - Based on [Pydnatic](https://pydantic-docs.helpmanual.io/): easily serialize structured data as part of RPC requests and responses (see 'tests/basic_rpc_test.py :: test_structured_response' for an example) + + - Client : + - Based on [Tenacity](https://tenacity.readthedocs.io/en/latest/index.html): allowing configurable retries to keep to connection alive + - see WebSocketRpcClient.__init__'s retry_config + - Based on python [websockets](https://websockets.readthedocs.io/en/stable/intro.html) - a more comprehensive client than the one offered by Fast-api + +## Logging +fastapi-websocket-rpc provides a helper logging module to control how it produces logs for you. +See [fastapi_websocket_rpc/logger.py](fastapi_websocket_rpc/logger.py). +Use ```logging_config.set_mode``` or the 'WS_RPC_LOGGING' environment variable to choose the logging method you prefer or override completely via default logging config. + +example: +```python +# set RPC to log like UVICORN +from fastapi_websocket_rpc.logger import logging_config, LoggingModes +logging_config.set_mode(LoggingModes.UVICORN) +``` + +## Pull requests - welcome! +- Please include tests for new features + + + + +%package help +Summary: Development documents and examples for fastapi-websocket-rpc +Provides: python3-fastapi-websocket-rpc-doc +%description help +<p align="center"> +<img src="https://i.ibb.co/m8jL6Zd/RPC.png" alt="RPC" border="0" width="50%" /> +</p> + +# + +# ⚡ FASTAPI Websocket RPC +RPC over Websockets made easy, robust, and production ready + +<a href="https://github.com/permitio/fastapi_websocket_rpc/actions?query=workflow%3ATests" target="_blank"> + <img src="https://github.com/permitio/fastapi_websocket_rpc/workflows/Tests/badge.svg" alt="Tests"> +</a> + +<a href="https://pypi.org/project/fastapi-websocket-rpc/" target="_blank"> + <img src="https://img.shields.io/pypi/v/fastapi-websocket-rpc?color=%2331C654&label=PyPi%20package" alt="Package"> +</a> + +<a href="https://pepy.tech/project/fastapi-websocket-rpc" target="_blank"> + <img src="https://static.pepy.tech/personalized-badge/fastapi-websocket-rpc?period=total&units=international_system&left_color=black&right_color=blue&left_text=Downloads" alt="Downloads"> +</a> + +A fast and durable bidirectional JSON RPC channel over Websockets. +The easiest way to create a live async channel between two nodes via Python (or other clients). + +- Both server and clients can easily expose Python methods that can be called by the other side. +Method return values are sent back as RPC responses, which the other side can wait on. +- Remote methods are easily called via the ```.other.method()``` wrapper +- Connections are kept alive with a configurable retry mechanism (using Tenacity) + +- As seen at <a href="https://www.youtube.com/watch?v=KP7tPeKhT3o" target="_blank">PyCon IL 2021</a> and <a href="https://www.youtube.com/watch?v=IuMZVWEUvGs" target="_blank">EuroPython 2021</a> + + +Supports and tested on Python >= 3.7 +## Installation 🛠️ +``` +pip install fastapi_websocket_rpc +``` + + +## RPC call example: + +Say the server exposes an "add" method, e.g. : +```python +class RpcCalculator(RpcMethodsBase): + async def add(self, a, b): + return a + b +``` +Calling it is as easy as calling the method under the client's "other" property: +```python +response = await client.other.add(a=1,b=2) +print(response.result) # 3 +``` +getting the response with the return value. + + + + +## Usage example: + +### Server: +```python +import uvicorn +from fastapi import FastAPI +from fastapi_websocket_rpc import RpcMethodsBase, WebsocketRPCEndpoint + +# Methods to expose to the clients +class ConcatServer(RpcMethodsBase): + async def concat(self, a="", b=""): + return a + b + +# Init the FAST-API app +app = FastAPI() +# Create an endpoint and load it with the methods to expose +endpoint = WebsocketRPCEndpoint(ConcatServer()) +# add the endpoint to the app +endpoint.register_route(app, "/ws") + +# Start the server itself +uvicorn.run(app, host="0.0.0.0", port=9000) +``` +### Client +```python +import asyncio +from fastapi_websocket_rpc import RpcMethodsBase, WebSocketRpcClient + +async def run_client(uri): + async with WebSocketRpcClient(uri, RpcMethodsBase()) as client: + # call concat on the other side + response = await client.other.concat(a="hello", b=" world") + # print result + print(response.result) # will print "hello world" + +# run the client until it completes interaction with server +asyncio.get_event_loop().run_until_complete( + run_client("ws://localhost:9000/ws") +) +``` + +See the [examples](/examples) and [tests](/tests) folders for more server and client examples + + +## Server calling client example: +- Clients can call ```client.other.method()``` + - which is a shortcut for ```channel.other.method()``` +- Servers also get the channel object and can call remote methods via ```channel.other.method()``` +- See the [bidirectional call example](examples/bidirectional_server_example.py) for calling client from server and server events (e.g. ```on_connect```). + + +## What can I do with this? +Websockets are ideal to create bi-directional realtime connections over the web. + - Push updates + - Remote control mechanism + - Pub / Sub (see [fastapi_websocket_pubsub](https://github.com/permitio/fastapi_websocket_pubsub)) + - Trigger events (see "tests/trigger_flow_test.py") + - Node negotiations (see "tests/advanced_rpc_test.py :: test_recursive_rpc_calls") + + +## Concepts +- [RpcChannel](fastapi_websocket_rpc/rpc_channel.py) - implements the RPC-protocol over the websocket + - Sending RpcRequests per method call + - Creating promises to track them (via unique call ids), and allow waiting for responses + - Executing methods on the remote side and serializing return values as + - Receiving RpcResponses and delivering them to waiting callers +- [RpcMethods](fastapi_websocket_rpc/rpc_methods.py) - classes passed to both client and server-endpoint inits to expose callable methods to the other side. + - Simply derive from RpcMethodsBase and add your own async methods + - Note currently only key-word arguments are supported + - Checkout RpcUtilityMethods for example methods, which are also useful debugging utilities + + +- Foundations: + + - Based on [asyncio](https://docs.python.org/3/library/asyncio.html) for the power of Python coroutines + + - Server Endpoint: + - Based on [FAST-API](https://github.com/tiangolo/fastapi): enjoy all the benefits of a full ASGI platform, including Async-io and dependency injections (for example to authenticate connections) + + - Based on [Pydnatic](https://pydantic-docs.helpmanual.io/): easily serialize structured data as part of RPC requests and responses (see 'tests/basic_rpc_test.py :: test_structured_response' for an example) + + - Client : + - Based on [Tenacity](https://tenacity.readthedocs.io/en/latest/index.html): allowing configurable retries to keep to connection alive + - see WebSocketRpcClient.__init__'s retry_config + - Based on python [websockets](https://websockets.readthedocs.io/en/stable/intro.html) - a more comprehensive client than the one offered by Fast-api + +## Logging +fastapi-websocket-rpc provides a helper logging module to control how it produces logs for you. +See [fastapi_websocket_rpc/logger.py](fastapi_websocket_rpc/logger.py). +Use ```logging_config.set_mode``` or the 'WS_RPC_LOGGING' environment variable to choose the logging method you prefer or override completely via default logging config. + +example: +```python +# set RPC to log like UVICORN +from fastapi_websocket_rpc.logger import logging_config, LoggingModes +logging_config.set_mode(LoggingModes.UVICORN) +``` + +## Pull requests - welcome! +- Please include tests for new features + + + + +%prep +%autosetup -n fastapi-websocket-rpc-0.1.24 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-fastapi-websocket-rpc -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Thu May 18 2023 Python_Bot <Python_Bot@openeuler.org> - 0.1.24-1 +- Package Spec generated |