%global _empty_manifest_terminate_build 0
Name:		python-graphyte
Version:	1.7.1
Release:	1
Summary:	Python 3 compatible library to send data to a Graphite metrics server (Carbon)
License:	MIT License
URL:		https://github.com/benhoyt/graphyte
Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/90/d8/516d885a705a341c6c681b8407350378f2b0f485056338166e4a108c8bec/graphyte-1.7.1.tar.gz
BuildArch:	noarch


%description
graphyte is a small Python library that sends data to a Graphite metrics
server (Carbon). We wrote it because the existing `graphitesend`_ library
didn’t support Python 3, and it also required gevent for asyncronous use.
graphyte is tested on Python 3.5+ as well as Python 2.7, and uses the
standard library’s ``threading`` module for asynchronous use.
The library is `on the Python Package Index (PyPI)`_, so to install it, fire up
a command prompt, activate your virtualenv if you’re using one, and type:
    pip install graphyte
Using graphyte is simple – just call ``init()`` to initialize the default
sender and then ``send()`` to send a message. For example, to send
``system.sync.foo.bar 42 {timestamp}\n`` to graphite.example.com:2003
synchronously:
    import graphyte
    graphyte.init('graphite.example.com', prefix='system.sync')
    graphyte.send('foo.bar', 42)
If you want to send asynchronously on a background thread (for example, in a
web server context), just specify a send interval. For example, this will
setup a background thread to send every 10 seconds:
    graphyte.init('graphite.example.com', prefix='system.async', interval=10)
    graphyte.send('foo.bar', 42)
If you want to send tagged metrics, the usage is as follows:
    graphite.send('foo.bar', 42, tags={'ding': 'dong'})
For more advanced usage, for example if you want to send to multiple servers
or if you want to subclass ``Sender``, you can instantiate instances of
``Sender`` directly. For example, to instantiate two senders sending to
different   servers (one synchronous, one using a background thread with send
interval 10   seconds), use something like the following:
    sender1 = graphyte.Sender('graphite1.example.com', prefix='system.one')
    sender2 = graphyte.Sender('graphite2.example.com', prefix='system.two', interval=10)
    sender1.send('foo.bar1', 42)
    sender2.send('foo.bar2', 43)
If you want to send via UDP instead of TCP, just add   ``protocol='udp'`` to
the ``init()`` or ``Sender()`` call.
Or, to customize how messages are logged or sent to the socket, subclass
``Sender`` and override ``send_message`` (or even ``send_socket`` if you
want to override logging and exception handling):
    class CustomSender(graphyte.Sender):
        def send_message(self, message):
            print('Sending bytes in some custom way: {!r}'.format(message))
By default, exceptions that occur when sending a message are logged. If you
want to raise and propagate exceptions instead, instantiate ``Sender`` with
``raise_send_errors=True``. It's an error to set ``raise_send_errors`` when
``interval`` is specified.
Socket sending errors are logged using the Python logging system (using
logger name “graphyte”). If the sender is initialized with
``log_sends=True``, all sends are logged at the INFO level.
You can also use graphyte to send metrics directly from the command line:
    python -m graphyte foo.bar 42
There are command line arguments to specify the server and port and other
configuration. Type ``python -m graphyte --help`` for help.
Read the code in `graphyte.py`_ for more details – it’s pretty small!
graphyte was written by `Ben Hoyt`_ and is licensed with a
permissive MIT license (see `LICENSE.txt`_).
**Related work:** `delphid`_ has a fork of graphyte which supports the statsd
protocol. See the changes on `delphid's branch`_.

%package -n python3-graphyte
Summary:	Python 3 compatible library to send data to a Graphite metrics server (Carbon)
Provides:	python-graphyte
BuildRequires:	python3-devel
BuildRequires:	python3-setuptools
BuildRequires:	python3-pip
%description -n python3-graphyte
graphyte is a small Python library that sends data to a Graphite metrics
server (Carbon). We wrote it because the existing `graphitesend`_ library
didn’t support Python 3, and it also required gevent for asyncronous use.
graphyte is tested on Python 3.5+ as well as Python 2.7, and uses the
standard library’s ``threading`` module for asynchronous use.
The library is `on the Python Package Index (PyPI)`_, so to install it, fire up
a command prompt, activate your virtualenv if you’re using one, and type:
    pip install graphyte
Using graphyte is simple – just call ``init()`` to initialize the default
sender and then ``send()`` to send a message. For example, to send
``system.sync.foo.bar 42 {timestamp}\n`` to graphite.example.com:2003
synchronously:
    import graphyte
    graphyte.init('graphite.example.com', prefix='system.sync')
    graphyte.send('foo.bar', 42)
If you want to send asynchronously on a background thread (for example, in a
web server context), just specify a send interval. For example, this will
setup a background thread to send every 10 seconds:
    graphyte.init('graphite.example.com', prefix='system.async', interval=10)
    graphyte.send('foo.bar', 42)
If you want to send tagged metrics, the usage is as follows:
    graphite.send('foo.bar', 42, tags={'ding': 'dong'})
For more advanced usage, for example if you want to send to multiple servers
or if you want to subclass ``Sender``, you can instantiate instances of
``Sender`` directly. For example, to instantiate two senders sending to
different   servers (one synchronous, one using a background thread with send
interval 10   seconds), use something like the following:
    sender1 = graphyte.Sender('graphite1.example.com', prefix='system.one')
    sender2 = graphyte.Sender('graphite2.example.com', prefix='system.two', interval=10)
    sender1.send('foo.bar1', 42)
    sender2.send('foo.bar2', 43)
If you want to send via UDP instead of TCP, just add   ``protocol='udp'`` to
the ``init()`` or ``Sender()`` call.
Or, to customize how messages are logged or sent to the socket, subclass
``Sender`` and override ``send_message`` (or even ``send_socket`` if you
want to override logging and exception handling):
    class CustomSender(graphyte.Sender):
        def send_message(self, message):
            print('Sending bytes in some custom way: {!r}'.format(message))
By default, exceptions that occur when sending a message are logged. If you
want to raise and propagate exceptions instead, instantiate ``Sender`` with
``raise_send_errors=True``. It's an error to set ``raise_send_errors`` when
``interval`` is specified.
Socket sending errors are logged using the Python logging system (using
logger name “graphyte”). If the sender is initialized with
``log_sends=True``, all sends are logged at the INFO level.
You can also use graphyte to send metrics directly from the command line:
    python -m graphyte foo.bar 42
There are command line arguments to specify the server and port and other
configuration. Type ``python -m graphyte --help`` for help.
Read the code in `graphyte.py`_ for more details – it’s pretty small!
graphyte was written by `Ben Hoyt`_ and is licensed with a
permissive MIT license (see `LICENSE.txt`_).
**Related work:** `delphid`_ has a fork of graphyte which supports the statsd
protocol. See the changes on `delphid's branch`_.

%package help
Summary:	Development documents and examples for graphyte
Provides:	python3-graphyte-doc
%description help
graphyte is a small Python library that sends data to a Graphite metrics
server (Carbon). We wrote it because the existing `graphitesend`_ library
didn’t support Python 3, and it also required gevent for asyncronous use.
graphyte is tested on Python 3.5+ as well as Python 2.7, and uses the
standard library’s ``threading`` module for asynchronous use.
The library is `on the Python Package Index (PyPI)`_, so to install it, fire up
a command prompt, activate your virtualenv if you’re using one, and type:
    pip install graphyte
Using graphyte is simple – just call ``init()`` to initialize the default
sender and then ``send()`` to send a message. For example, to send
``system.sync.foo.bar 42 {timestamp}\n`` to graphite.example.com:2003
synchronously:
    import graphyte
    graphyte.init('graphite.example.com', prefix='system.sync')
    graphyte.send('foo.bar', 42)
If you want to send asynchronously on a background thread (for example, in a
web server context), just specify a send interval. For example, this will
setup a background thread to send every 10 seconds:
    graphyte.init('graphite.example.com', prefix='system.async', interval=10)
    graphyte.send('foo.bar', 42)
If you want to send tagged metrics, the usage is as follows:
    graphite.send('foo.bar', 42, tags={'ding': 'dong'})
For more advanced usage, for example if you want to send to multiple servers
or if you want to subclass ``Sender``, you can instantiate instances of
``Sender`` directly. For example, to instantiate two senders sending to
different   servers (one synchronous, one using a background thread with send
interval 10   seconds), use something like the following:
    sender1 = graphyte.Sender('graphite1.example.com', prefix='system.one')
    sender2 = graphyte.Sender('graphite2.example.com', prefix='system.two', interval=10)
    sender1.send('foo.bar1', 42)
    sender2.send('foo.bar2', 43)
If you want to send via UDP instead of TCP, just add   ``protocol='udp'`` to
the ``init()`` or ``Sender()`` call.
Or, to customize how messages are logged or sent to the socket, subclass
``Sender`` and override ``send_message`` (or even ``send_socket`` if you
want to override logging and exception handling):
    class CustomSender(graphyte.Sender):
        def send_message(self, message):
            print('Sending bytes in some custom way: {!r}'.format(message))
By default, exceptions that occur when sending a message are logged. If you
want to raise and propagate exceptions instead, instantiate ``Sender`` with
``raise_send_errors=True``. It's an error to set ``raise_send_errors`` when
``interval`` is specified.
Socket sending errors are logged using the Python logging system (using
logger name “graphyte”). If the sender is initialized with
``log_sends=True``, all sends are logged at the INFO level.
You can also use graphyte to send metrics directly from the command line:
    python -m graphyte foo.bar 42
There are command line arguments to specify the server and port and other
configuration. Type ``python -m graphyte --help`` for help.
Read the code in `graphyte.py`_ for more details – it’s pretty small!
graphyte was written by `Ben Hoyt`_ and is licensed with a
permissive MIT license (see `LICENSE.txt`_).
**Related work:** `delphid`_ has a fork of graphyte which supports the statsd
protocol. See the changes on `delphid's branch`_.

%prep
%autosetup -n graphyte-1.7.1

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

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

%changelog
* Sun Apr 23 2023 Python_Bot <Python_Bot@openeuler.org> - 1.7.1-1
- Package Spec generated