%global _empty_manifest_terminate_build 0
Name:		python-asyncua
Version:	1.0.2
Release:	1
Summary:	Pure Python OPC-UA client and server library
License:	GNU Lesser General Public License v3 or later
URL:		http://freeopcua.github.io/
Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/f6/cb/192ad94b0136c0a3a56ceb14353b19374b4144c743aba8c9c6e273be083d/asyncua-1.0.2.tar.gz
BuildArch:	noarch

Requires:	python3-aiofiles
Requires:	python3-aiosqlite
Requires:	python3-dateutil
Requires:	python3-pytz
Requires:	python3-cryptography
Requires:	python3-sortedcontainers
Requires:	python3-importlib-metadata

%description
OPC UA binary protocol implementation has been tested against many different OPC UA stacks. API offers both a low level interface to send and receive all UA defined structures and high level classes allowing to write a server or a client in a few lines. It is easy to mix high level objects and low level UA calls in one application. Most low level code is autogenerated from xml specification.
coverage.py reports a test coverage of over 95 % of code, most of non-tested code is autogenerated code that is not used yet.
# Warnings
opcua-asyncio is open-source and comes with absolutely no warranty. We try to keep it as much bug-free as possible and try to keep API stable but bugs and API changes will happen! Especially API changes will happen before any 1.0 release.
Some renaming of methods from get_xx to read_xx and set_xx to write_xxx have been made to better follow OPC UA naming conventions
Version 0.9.9 introduces some argument renaming due to more automatic code generation. Especially the arguments to NodeId, BrowseName, LocalizedText and DataValue are now CamelCase instead of lower case, thus follow the OPC Ua convention used in all other structures in this library
# Installation
With pip
    pip install asyncua
# Usage
We assume that you already have some experience with Python, the asyncio module, the async / await syntax and the concept of asyncio Tasks.
## Client class
The `Client` class provides a high level API for connecting to APU UA servers, session management and access to basic
address space services.
The client can be used as a context manager. The client will then automatically connect and disconnect withing the `with`syntax.
```python
from asyncua import Client
async with Client(url='opc.tcp://localhost:4840/freeopcua/server/') as client:
    while True:
        # Do something with client
        node = client.get_node('i=85')
        value = await node.read_value()
```
Of course, you can also call the `connect`, `disconnect` methods yourself if you do not want to use the context manager.
See the example folder and the code for more information on the client API.
## Node class
The `Node` class provides a high level API for management of nodes as well as data access services.
## Subscription class
The `Subscription` class provides a high level API for management of monitored items.
## Server class
The `Server` class provides a high level API for creation of OPC UA server instances.
# Documentation
The documentation is available here [ReadTheDocs](http://opcua-asyncio.readthedocs.org/en/latest/).
The API remains mostly unchanged in regards to [python-opcua](http://opcua-asyncio.rtfd.io/).
Main difference is that most methods are now async.
Please have a look at [the examples](https://github.com/FreeOpcUa/opcua-asyncio/blob/master/examples) and/or the code.
A simple GUI client is available: https://github.com/FreeOpcUa/opcua-client-gui
Browse the examples: https://github.com/FreeOpcUa/opcua-asyncio/tree/master/examples
A good starting point are the minimal examples.
Minimal client example: https://github.com/FreeOpcUa/opcua-asyncio/blob/master/examples/client-minimal.py
Minimal server example: https://github.com/FreeOpcUa/opcua-asyncio/blob/master/examples/server-minimal.py
A set of command line tools also available: https://github.com/FreeOpcUa/opcua-asyncio/tree/master/tools
* `uadiscover `(find_servers, get_endpoints and find_servers_on_network calls)
* `uals `(list children of a node)
* `uahistoryread`
* `uaread `(read attribute of a node)
* `uawrite `(write attribute of a node)
* `uacall `(call method of a node)
* `uasubscribe `(subscribe to a node and print datachange events)
* `uaclient `(connect to server and start python shell)
* `uaserver `(starts a demo OPC UA server)
  `tools/uaserver --populate --certificate cert.pem --private_key pk.pem`
How to generate certificate: https://github.com/FreeOpcUa/opcua-asyncio/tree/master/examples/generate_certificate.sh
## Client support
What works:
* connection to server, opening channel, session
* browsing and reading attributes value
* getting nodes by path and nodeids
* creating subscriptions
* subscribing to items for data change
* subscribing to events
* adding nodes
* method call
* user and password
* history read
* login with certificate
* communication encryption
* removing nodes
Tested servers: freeopcua C++, freeopcua Python, prosys, kepware, beckhoff, winCC, B&R, …
Not implemented yet:
* localized text feature
* XML protocol
* UDP (PubSub stuff)
* WebSocket
* maybe automatic reconnection...
## Server support
What works:
* creating channel and sessions
* read/set attributes and browse
* getting nodes by path and nodeids
* autogenerate address space from spec
* adding nodes to address space
* datachange events
* events
* methods
* basic user implementation (one existing user called admin, which can be disabled, all others are read only)
* encryption
* certificate handling
* removing nodes
* history support for data change and events
* more high level solution to create custom structures
Tested clients: freeopcua C++, freeopcua Python, uaexpert, prosys, quickopc
Not yet implemented:
* UDP (PubSub stuff)
* WebSocket
* session restore
* alarms
* XML protocol
* views
* localized text features
* better security model with users and password
### Running a server on a Raspberry Pi
Setting up the standard address-space from XML is the most time-consuming step of the startup process which may lead to
long startup times on less powerful devices like a Raspberry Pi. By passing a path to a cache-file to the server constructor,
a shelve holding the address space will be created during the first startup. All following startups will make use of the
cache-file which leads to significantly better startup performance (~3.5 vs 125 seconds on a Raspberry Pi Model B).
# Development
Code follows PEP8 apart for line lengths which should be max 160 characters and OPC UA structures that keep camel case
from XML definition.
All protocol code is under opcua directory
- `asyncua/ua` contains all UA structures from specification, most are autogenerated
- `asyncua/common` contains high level objects and methods used both in server and client
- `asyncua/client` contains client specific code
- `asyncua/server` contains server specific code
- `asyncua/utils` contains some utilities function and classes
- `asyncua/tools` contains code for command lines tools
- `schemas` contains the XML and text files from specification and the python scripts used to autogenerate code
- `tests` contains tests
- `docs` contains files to auto generate documentation from doc strings
- `examples` contains many example files
- `examples/sync` contains many example files using sync API
- `tools` contains python scripts that can be used to run command line tools from repository without installing
## Running tests:
```
python -m pip install -r requirements.txt
python -m pip install -r dev_requirements.txt
pytest -v -s
```
Or
```
./run-test.sh -v -s
```
## Coverage
```
pytest -v -s --cov asyncua --cov-report=html
```
Or
```
./run-test.sh -v -s --cov asyncua --cov-report=html
```

%package -n python3-asyncua
Summary:	Pure Python OPC-UA client and server library
Provides:	python-asyncua
BuildRequires:	python3-devel
BuildRequires:	python3-setuptools
BuildRequires:	python3-pip
%description -n python3-asyncua
OPC UA binary protocol implementation has been tested against many different OPC UA stacks. API offers both a low level interface to send and receive all UA defined structures and high level classes allowing to write a server or a client in a few lines. It is easy to mix high level objects and low level UA calls in one application. Most low level code is autogenerated from xml specification.
coverage.py reports a test coverage of over 95 % of code, most of non-tested code is autogenerated code that is not used yet.
# Warnings
opcua-asyncio is open-source and comes with absolutely no warranty. We try to keep it as much bug-free as possible and try to keep API stable but bugs and API changes will happen! Especially API changes will happen before any 1.0 release.
Some renaming of methods from get_xx to read_xx and set_xx to write_xxx have been made to better follow OPC UA naming conventions
Version 0.9.9 introduces some argument renaming due to more automatic code generation. Especially the arguments to NodeId, BrowseName, LocalizedText and DataValue are now CamelCase instead of lower case, thus follow the OPC Ua convention used in all other structures in this library
# Installation
With pip
    pip install asyncua
# Usage
We assume that you already have some experience with Python, the asyncio module, the async / await syntax and the concept of asyncio Tasks.
## Client class
The `Client` class provides a high level API for connecting to APU UA servers, session management and access to basic
address space services.
The client can be used as a context manager. The client will then automatically connect and disconnect withing the `with`syntax.
```python
from asyncua import Client
async with Client(url='opc.tcp://localhost:4840/freeopcua/server/') as client:
    while True:
        # Do something with client
        node = client.get_node('i=85')
        value = await node.read_value()
```
Of course, you can also call the `connect`, `disconnect` methods yourself if you do not want to use the context manager.
See the example folder and the code for more information on the client API.
## Node class
The `Node` class provides a high level API for management of nodes as well as data access services.
## Subscription class
The `Subscription` class provides a high level API for management of monitored items.
## Server class
The `Server` class provides a high level API for creation of OPC UA server instances.
# Documentation
The documentation is available here [ReadTheDocs](http://opcua-asyncio.readthedocs.org/en/latest/).
The API remains mostly unchanged in regards to [python-opcua](http://opcua-asyncio.rtfd.io/).
Main difference is that most methods are now async.
Please have a look at [the examples](https://github.com/FreeOpcUa/opcua-asyncio/blob/master/examples) and/or the code.
A simple GUI client is available: https://github.com/FreeOpcUa/opcua-client-gui
Browse the examples: https://github.com/FreeOpcUa/opcua-asyncio/tree/master/examples
A good starting point are the minimal examples.
Minimal client example: https://github.com/FreeOpcUa/opcua-asyncio/blob/master/examples/client-minimal.py
Minimal server example: https://github.com/FreeOpcUa/opcua-asyncio/blob/master/examples/server-minimal.py
A set of command line tools also available: https://github.com/FreeOpcUa/opcua-asyncio/tree/master/tools
* `uadiscover `(find_servers, get_endpoints and find_servers_on_network calls)
* `uals `(list children of a node)
* `uahistoryread`
* `uaread `(read attribute of a node)
* `uawrite `(write attribute of a node)
* `uacall `(call method of a node)
* `uasubscribe `(subscribe to a node and print datachange events)
* `uaclient `(connect to server and start python shell)
* `uaserver `(starts a demo OPC UA server)
  `tools/uaserver --populate --certificate cert.pem --private_key pk.pem`
How to generate certificate: https://github.com/FreeOpcUa/opcua-asyncio/tree/master/examples/generate_certificate.sh
## Client support
What works:
* connection to server, opening channel, session
* browsing and reading attributes value
* getting nodes by path and nodeids
* creating subscriptions
* subscribing to items for data change
* subscribing to events
* adding nodes
* method call
* user and password
* history read
* login with certificate
* communication encryption
* removing nodes
Tested servers: freeopcua C++, freeopcua Python, prosys, kepware, beckhoff, winCC, B&R, …
Not implemented yet:
* localized text feature
* XML protocol
* UDP (PubSub stuff)
* WebSocket
* maybe automatic reconnection...
## Server support
What works:
* creating channel and sessions
* read/set attributes and browse
* getting nodes by path and nodeids
* autogenerate address space from spec
* adding nodes to address space
* datachange events
* events
* methods
* basic user implementation (one existing user called admin, which can be disabled, all others are read only)
* encryption
* certificate handling
* removing nodes
* history support for data change and events
* more high level solution to create custom structures
Tested clients: freeopcua C++, freeopcua Python, uaexpert, prosys, quickopc
Not yet implemented:
* UDP (PubSub stuff)
* WebSocket
* session restore
* alarms
* XML protocol
* views
* localized text features
* better security model with users and password
### Running a server on a Raspberry Pi
Setting up the standard address-space from XML is the most time-consuming step of the startup process which may lead to
long startup times on less powerful devices like a Raspberry Pi. By passing a path to a cache-file to the server constructor,
a shelve holding the address space will be created during the first startup. All following startups will make use of the
cache-file which leads to significantly better startup performance (~3.5 vs 125 seconds on a Raspberry Pi Model B).
# Development
Code follows PEP8 apart for line lengths which should be max 160 characters and OPC UA structures that keep camel case
from XML definition.
All protocol code is under opcua directory
- `asyncua/ua` contains all UA structures from specification, most are autogenerated
- `asyncua/common` contains high level objects and methods used both in server and client
- `asyncua/client` contains client specific code
- `asyncua/server` contains server specific code
- `asyncua/utils` contains some utilities function and classes
- `asyncua/tools` contains code for command lines tools
- `schemas` contains the XML and text files from specification and the python scripts used to autogenerate code
- `tests` contains tests
- `docs` contains files to auto generate documentation from doc strings
- `examples` contains many example files
- `examples/sync` contains many example files using sync API
- `tools` contains python scripts that can be used to run command line tools from repository without installing
## Running tests:
```
python -m pip install -r requirements.txt
python -m pip install -r dev_requirements.txt
pytest -v -s
```
Or
```
./run-test.sh -v -s
```
## Coverage
```
pytest -v -s --cov asyncua --cov-report=html
```
Or
```
./run-test.sh -v -s --cov asyncua --cov-report=html
```

%package help
Summary:	Development documents and examples for asyncua
Provides:	python3-asyncua-doc
%description help
OPC UA binary protocol implementation has been tested against many different OPC UA stacks. API offers both a low level interface to send and receive all UA defined structures and high level classes allowing to write a server or a client in a few lines. It is easy to mix high level objects and low level UA calls in one application. Most low level code is autogenerated from xml specification.
coverage.py reports a test coverage of over 95 % of code, most of non-tested code is autogenerated code that is not used yet.
# Warnings
opcua-asyncio is open-source and comes with absolutely no warranty. We try to keep it as much bug-free as possible and try to keep API stable but bugs and API changes will happen! Especially API changes will happen before any 1.0 release.
Some renaming of methods from get_xx to read_xx and set_xx to write_xxx have been made to better follow OPC UA naming conventions
Version 0.9.9 introduces some argument renaming due to more automatic code generation. Especially the arguments to NodeId, BrowseName, LocalizedText and DataValue are now CamelCase instead of lower case, thus follow the OPC Ua convention used in all other structures in this library
# Installation
With pip
    pip install asyncua
# Usage
We assume that you already have some experience with Python, the asyncio module, the async / await syntax and the concept of asyncio Tasks.
## Client class
The `Client` class provides a high level API for connecting to APU UA servers, session management and access to basic
address space services.
The client can be used as a context manager. The client will then automatically connect and disconnect withing the `with`syntax.
```python
from asyncua import Client
async with Client(url='opc.tcp://localhost:4840/freeopcua/server/') as client:
    while True:
        # Do something with client
        node = client.get_node('i=85')
        value = await node.read_value()
```
Of course, you can also call the `connect`, `disconnect` methods yourself if you do not want to use the context manager.
See the example folder and the code for more information on the client API.
## Node class
The `Node` class provides a high level API for management of nodes as well as data access services.
## Subscription class
The `Subscription` class provides a high level API for management of monitored items.
## Server class
The `Server` class provides a high level API for creation of OPC UA server instances.
# Documentation
The documentation is available here [ReadTheDocs](http://opcua-asyncio.readthedocs.org/en/latest/).
The API remains mostly unchanged in regards to [python-opcua](http://opcua-asyncio.rtfd.io/).
Main difference is that most methods are now async.
Please have a look at [the examples](https://github.com/FreeOpcUa/opcua-asyncio/blob/master/examples) and/or the code.
A simple GUI client is available: https://github.com/FreeOpcUa/opcua-client-gui
Browse the examples: https://github.com/FreeOpcUa/opcua-asyncio/tree/master/examples
A good starting point are the minimal examples.
Minimal client example: https://github.com/FreeOpcUa/opcua-asyncio/blob/master/examples/client-minimal.py
Minimal server example: https://github.com/FreeOpcUa/opcua-asyncio/blob/master/examples/server-minimal.py
A set of command line tools also available: https://github.com/FreeOpcUa/opcua-asyncio/tree/master/tools
* `uadiscover `(find_servers, get_endpoints and find_servers_on_network calls)
* `uals `(list children of a node)
* `uahistoryread`
* `uaread `(read attribute of a node)
* `uawrite `(write attribute of a node)
* `uacall `(call method of a node)
* `uasubscribe `(subscribe to a node and print datachange events)
* `uaclient `(connect to server and start python shell)
* `uaserver `(starts a demo OPC UA server)
  `tools/uaserver --populate --certificate cert.pem --private_key pk.pem`
How to generate certificate: https://github.com/FreeOpcUa/opcua-asyncio/tree/master/examples/generate_certificate.sh
## Client support
What works:
* connection to server, opening channel, session
* browsing and reading attributes value
* getting nodes by path and nodeids
* creating subscriptions
* subscribing to items for data change
* subscribing to events
* adding nodes
* method call
* user and password
* history read
* login with certificate
* communication encryption
* removing nodes
Tested servers: freeopcua C++, freeopcua Python, prosys, kepware, beckhoff, winCC, B&R, …
Not implemented yet:
* localized text feature
* XML protocol
* UDP (PubSub stuff)
* WebSocket
* maybe automatic reconnection...
## Server support
What works:
* creating channel and sessions
* read/set attributes and browse
* getting nodes by path and nodeids
* autogenerate address space from spec
* adding nodes to address space
* datachange events
* events
* methods
* basic user implementation (one existing user called admin, which can be disabled, all others are read only)
* encryption
* certificate handling
* removing nodes
* history support for data change and events
* more high level solution to create custom structures
Tested clients: freeopcua C++, freeopcua Python, uaexpert, prosys, quickopc
Not yet implemented:
* UDP (PubSub stuff)
* WebSocket
* session restore
* alarms
* XML protocol
* views
* localized text features
* better security model with users and password
### Running a server on a Raspberry Pi
Setting up the standard address-space from XML is the most time-consuming step of the startup process which may lead to
long startup times on less powerful devices like a Raspberry Pi. By passing a path to a cache-file to the server constructor,
a shelve holding the address space will be created during the first startup. All following startups will make use of the
cache-file which leads to significantly better startup performance (~3.5 vs 125 seconds on a Raspberry Pi Model B).
# Development
Code follows PEP8 apart for line lengths which should be max 160 characters and OPC UA structures that keep camel case
from XML definition.
All protocol code is under opcua directory
- `asyncua/ua` contains all UA structures from specification, most are autogenerated
- `asyncua/common` contains high level objects and methods used both in server and client
- `asyncua/client` contains client specific code
- `asyncua/server` contains server specific code
- `asyncua/utils` contains some utilities function and classes
- `asyncua/tools` contains code for command lines tools
- `schemas` contains the XML and text files from specification and the python scripts used to autogenerate code
- `tests` contains tests
- `docs` contains files to auto generate documentation from doc strings
- `examples` contains many example files
- `examples/sync` contains many example files using sync API
- `tools` contains python scripts that can be used to run command line tools from repository without installing
## Running tests:
```
python -m pip install -r requirements.txt
python -m pip install -r dev_requirements.txt
pytest -v -s
```
Or
```
./run-test.sh -v -s
```
## Coverage
```
pytest -v -s --cov asyncua --cov-report=html
```
Or
```
./run-test.sh -v -s --cov asyncua --cov-report=html
```

%prep
%autosetup -n asyncua-1.0.2

%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-asyncua -f filelist.lst
%dir %{python3_sitelib}/*

%files help -f doclist.lst
%{_docdir}/*

%changelog
* Wed Apr 12 2023 Python_Bot <Python_Bot@openeuler.org> - 1.0.2-1
- Package Spec generated