%global _empty_manifest_terminate_build 0
Name: python-toolbox
Version: 1.11.0
Release: 1
Summary: Extends Python with useful features.
License: MIT
URL: https://github.com/synchronizing/toolbox
Source0: https://mirrors.nju.edu.cn/pypi/web/packages/54/42/27357827649818b5b6cc86c1b90138e4016b1dd6e469c6b05ae0374ed95e/toolbox-1.11.0.tar.gz
BuildArch: noarch
%description
# 🧰 Toolbox
Toolbox is a small (~0.2MB) set of tools that expands the [Python Standard Library](https://docs.python.org/3/library/).
## Installing
```
pip install toolbox
```
## Documentation
Documentation can be found [**here**](http://synchronizing.github.io/toolbox/).
## Tools
### `asyncio`
future_lru_cache — lru_cache for async functions.
```python
from toolbox import future_lru_cache
import asyncio
@future_lru_cache
async def func():
await asyncio.sleep(10)
return 42
async def main():
await func() # Runs once.
await func() # Returns cached value.
asyncio.run(main())
````
to_thread — Run a synchronous function in a separate thread.
```python
from toolbox import to_thread
import asyncio
import time
def func():
time.sleep(2)
return "Hello world"
async def main():
await to_thread(func)
asyncio.run(main())
````
awaitable — Convert synchronous function to an async function via thread.
Leverages the `to_thread` function above.
```python
from toolbox import awaitable
import asyncio
import time
@awaitable
def func():
time.sleep(2)
return "Hello world"
async def main():
await func()
asyncio.run(func())
```
tls_handshake — Perform TLS handshake with a stream reader & writer.
```python
from toolbox import tls_handshake
import asyncio
async def client():
reader, writer = await asyncio.open_connection("httpbin.org", 443, ssl=False)
await tls_handshake(reader=reader, writer=writer)
# Communication is now encrypted.
asyncio.run(client())
```
CoroutineClass — Class pattern for implementing object-based coroutines.
Pattern for creating a coroutine-like class that has multiple ways to start it.
```python
from toolbox import CoroutineClass
import asyncio
class Coroutine(CoroutineClass):
def __init__(self, run: bool = False):
super().__init__(run=run)
# Default entry function.
async def entry(self):
await asyncio.sleep(1)
return "Hello world"
# Start coroutine outside Python async context.
def iomain():
# via __init__
coro = Coroutine(run=True)
print(coro.result) # Hello world
# via .run()
coro = Coroutine()
result = coro.run()
print(result) # Hello world
# Start coroutine inside Python async context.
async def aiomain():
# via __init__
coro = Coroutine(run=True)
await asyncio.sleep(1)
coro.stop()
print(coro.result) # None - because process was stopped before completion.
# via .run()
coro = Coroutine()
coro.run()
await asyncio.sleep(1)
result = coro.stop() # None - because coroutine was stopped before completion.
print(result) # Hello world
# via await
coro = Coroutine()
result = await coro # You can also start, and await later.
print(result) # Hello World
# via context manager
async with Coroutine() as coro:
result = await coro
print(result) # Hello World
```
### `builtins`
classproperty — Decorator for defining a method as a property and classmethod.
Allows access to computed class attributes.
```python
from toolbox import classproperty
class Animal:
@classproperty
def dog(cls):
return "whoof!"
print(Animal.dog) # 'whoof!'
```
### `collections`
Item — An interface for type-agnostic operations between different types.
```python
from toolbox import Item
item = Item(100)
print(item == b"100" == "100" == 100) # True
```
nestednamedtuple — Creates a nested namedtuple.
```python
from toolbox import nestednamedtuple
nt = nestednamedtuple({"hello": {"ola": "mundo"}})
print(nt) # namedtupled(hello=namedtupled(ola='mundo'))
print(nt.hello.ola) # mundo
```
fdict — Forces nestednamedtuple to not convert dict to namedtuple.
```python
from toolbox import nestednamedtuple, fdict
d = {"hello": "world"}
nt = nestednamedtuple({"forced": fdict(d), "notforced": d})
print(nt.notforced) # namedtupled(hello='world')
print(nt.forced) # {'hello': 'world'}
```
BidirectionalDict — Dictionary with two-way capabilities.
```python
from toolbox import BidirectionalDict
d = BidirectionalDict({"hello": "world"})
print(d) # {'hello': 'world', 'world': 'hello'}
```
ObjectDict — Dictionary that can be accessed as though it was an object.
```python
from toolbox import ObjectDict
d = ObjectDict({"hello": "world"})
print(d.hello) # 'world'
```
OverloadedDict — Dictionary that can be added or subtracted to.
```python
from toolbox import OverloadedDict
d1 = OverloadedDict({"hello": "world"})
d2 = OverloadedDict({"ola": "mundo"})
d1 += d2
print(d1) # {'hello': 'world', 'ola': 'mundo'}
d1 -= d2
print(d1) # {'hello': 'world'}
```
UnderscoreAccessDict — Dictionary with underscore access.
```python
from toolbox import UnderscoreAccessDict
d = UnderscoreAccessDict({"hello": "world"})
print(d.hello) # 'world'
```
FrozenDict — Dictionary that is frozen.
```python
from toolbox import FrozenDict
d = FrozenDict({"hello": "world"})
d["hello"] = "mundo" # KeyError: Cannot set key and value because this is a frozen dictionary.
```
MultiEntryDict — Dictionary that can have multiple entries for the same key.
```python
from toolbox import MultiEntryDict
d = MultiEntryDict({"hello": "world"})
d["hello"] = "mundo"
print(d) # {'hello': ['world', 'mundo']}
```
ItemDict — Dictionary that utilizes Item for key and values.
```python
from toolbox import ItemDict, Item
d = ItemDict({"100": "one hundred"})
print(d[100]) # one hundred
print(d[100] == d['100'] == d[b'100'] == d[Item(100)]) # True
```
All `*Dict` types above can be combined together (as mixins) to create unique dictionary types.
### `config`
make_config — Stores configuration dictionary in-memory.
Creates a global configuration that can be accessed by other portions of the code via `conf` or `config` function calls. Minimizes the need to create `Config` objects and pass them around different modules, classes, functions, etc.
```python
from toolbox import make_config
make_config(hello="world")
```
config — Access in-memory configuration as dictionary.
```python
from toolbox import config
print(config()['hello']) # 'world'
```
conf — Access in-memory configuration as nestednametuple.
```python
from toolbox import conf
print(conf().hello) # 'world'
```
### `functools`
timeout — Decorator to add timeout for synchronous and asychronous functions.
Decorator that adds support for synchronous and asynchronous function timeout. Quits function after an amount of time passes.
```python
from toolbox import timeout
import asyncio
import time
@timeout(seconds=1)
def func():
time.sleep(15)
@timeout(seconds=1)
async def func():
await asyncio.sleep(15)
```
### `pdb`
sprinkle — Prints the line and file that this function was just called from.
```python
from toolbox.pdb.sprinkle import sprinkle
sprinkle() # >>> 3 this_file.py
sprinkle("hello", "world") # >>> 4 this_file.py hello world
```
### `pkgutil`
search_package — Searches for packages installed in the system.
```python
from toolbox import search_package
print(search_package("toolbox", method="is"))
# {'toolbox': }
```
### `sockets`
is_ip — Checks if a string is an IP address.
```python
from toolbox import is_ip
print(is_ip('127.0.0.1')) # True
print(is_ip('localhost')) # False
```
### `string`
ANSI Formatting — Color formatting.
Check documentation [here](https://synchronizing.github.io/toolbox/module/string.html#color) for further information on all built-in formats.
```python
from toolbox import bold, red
print(red("This text is red!"))
print(bold("This text is bolded!"))
```
Format — Persistent ANSI formatter that takes a custom ANSI code.
```python
from toolbox import Format
bold = Format(code=1)
print(bold("hello world"))
```
Style — Persistent ANSI formatter that allows multiple ANSI codes.
```python
from toolbox import Style, red, bold
error = Style(red, bold)
print(error("This is red & bolded error."))
```
supports_color — Check's if the user's terminal supports color.
```python
from toolbox import supports_color
print(supports_color()) # True
```
strip_ansi — Removes ANSI codes from string.
```python
from toolbox import strip_ansi
print(strip_ansi("\x1b[1mhello world\x1b[0m")) # hello world
```
### `textwrap`
unindent — Removes indent and white-space from docstrings.
```python
from toolbox import unindent
def test():
text = """
hello world
this is a test
"""
print(text)
text = unindent(
"""
hello world
this is a test
"""
)
print(text)
test()
# hello world
# this is a test
#
# hello world
# this is a test
```
%package -n python3-toolbox
Summary: Extends Python with useful features.
Provides: python-toolbox
BuildRequires: python3-devel
BuildRequires: python3-setuptools
BuildRequires: python3-pip
%description -n python3-toolbox
# 🧰 Toolbox
Toolbox is a small (~0.2MB) set of tools that expands the [Python Standard Library](https://docs.python.org/3/library/).
## Installing
```
pip install toolbox
```
## Documentation
Documentation can be found [**here**](http://synchronizing.github.io/toolbox/).
## Tools
### `asyncio`
future_lru_cache — lru_cache for async functions.
```python
from toolbox import future_lru_cache
import asyncio
@future_lru_cache
async def func():
await asyncio.sleep(10)
return 42
async def main():
await func() # Runs once.
await func() # Returns cached value.
asyncio.run(main())
````
to_thread — Run a synchronous function in a separate thread.
```python
from toolbox import to_thread
import asyncio
import time
def func():
time.sleep(2)
return "Hello world"
async def main():
await to_thread(func)
asyncio.run(main())
````
awaitable — Convert synchronous function to an async function via thread.
Leverages the `to_thread` function above.
```python
from toolbox import awaitable
import asyncio
import time
@awaitable
def func():
time.sleep(2)
return "Hello world"
async def main():
await func()
asyncio.run(func())
```
tls_handshake — Perform TLS handshake with a stream reader & writer.
```python
from toolbox import tls_handshake
import asyncio
async def client():
reader, writer = await asyncio.open_connection("httpbin.org", 443, ssl=False)
await tls_handshake(reader=reader, writer=writer)
# Communication is now encrypted.
asyncio.run(client())
```
CoroutineClass — Class pattern for implementing object-based coroutines.
Pattern for creating a coroutine-like class that has multiple ways to start it.
```python
from toolbox import CoroutineClass
import asyncio
class Coroutine(CoroutineClass):
def __init__(self, run: bool = False):
super().__init__(run=run)
# Default entry function.
async def entry(self):
await asyncio.sleep(1)
return "Hello world"
# Start coroutine outside Python async context.
def iomain():
# via __init__
coro = Coroutine(run=True)
print(coro.result) # Hello world
# via .run()
coro = Coroutine()
result = coro.run()
print(result) # Hello world
# Start coroutine inside Python async context.
async def aiomain():
# via __init__
coro = Coroutine(run=True)
await asyncio.sleep(1)
coro.stop()
print(coro.result) # None - because process was stopped before completion.
# via .run()
coro = Coroutine()
coro.run()
await asyncio.sleep(1)
result = coro.stop() # None - because coroutine was stopped before completion.
print(result) # Hello world
# via await
coro = Coroutine()
result = await coro # You can also start, and await later.
print(result) # Hello World
# via context manager
async with Coroutine() as coro:
result = await coro
print(result) # Hello World
```
### `builtins`
classproperty — Decorator for defining a method as a property and classmethod.
Allows access to computed class attributes.
```python
from toolbox import classproperty
class Animal:
@classproperty
def dog(cls):
return "whoof!"
print(Animal.dog) # 'whoof!'
```
### `collections`
Item — An interface for type-agnostic operations between different types.
```python
from toolbox import Item
item = Item(100)
print(item == b"100" == "100" == 100) # True
```
nestednamedtuple — Creates a nested namedtuple.
```python
from toolbox import nestednamedtuple
nt = nestednamedtuple({"hello": {"ola": "mundo"}})
print(nt) # namedtupled(hello=namedtupled(ola='mundo'))
print(nt.hello.ola) # mundo
```
fdict — Forces nestednamedtuple to not convert dict to namedtuple.
```python
from toolbox import nestednamedtuple, fdict
d = {"hello": "world"}
nt = nestednamedtuple({"forced": fdict(d), "notforced": d})
print(nt.notforced) # namedtupled(hello='world')
print(nt.forced) # {'hello': 'world'}
```
BidirectionalDict — Dictionary with two-way capabilities.
```python
from toolbox import BidirectionalDict
d = BidirectionalDict({"hello": "world"})
print(d) # {'hello': 'world', 'world': 'hello'}
```
ObjectDict — Dictionary that can be accessed as though it was an object.
```python
from toolbox import ObjectDict
d = ObjectDict({"hello": "world"})
print(d.hello) # 'world'
```
OverloadedDict — Dictionary that can be added or subtracted to.
```python
from toolbox import OverloadedDict
d1 = OverloadedDict({"hello": "world"})
d2 = OverloadedDict({"ola": "mundo"})
d1 += d2
print(d1) # {'hello': 'world', 'ola': 'mundo'}
d1 -= d2
print(d1) # {'hello': 'world'}
```
UnderscoreAccessDict — Dictionary with underscore access.
```python
from toolbox import UnderscoreAccessDict
d = UnderscoreAccessDict({"hello": "world"})
print(d.hello) # 'world'
```
FrozenDict — Dictionary that is frozen.
```python
from toolbox import FrozenDict
d = FrozenDict({"hello": "world"})
d["hello"] = "mundo" # KeyError: Cannot set key and value because this is a frozen dictionary.
```
MultiEntryDict — Dictionary that can have multiple entries for the same key.
```python
from toolbox import MultiEntryDict
d = MultiEntryDict({"hello": "world"})
d["hello"] = "mundo"
print(d) # {'hello': ['world', 'mundo']}
```
ItemDict — Dictionary that utilizes Item for key and values.
```python
from toolbox import ItemDict, Item
d = ItemDict({"100": "one hundred"})
print(d[100]) # one hundred
print(d[100] == d['100'] == d[b'100'] == d[Item(100)]) # True
```
All `*Dict` types above can be combined together (as mixins) to create unique dictionary types.
### `config`
make_config — Stores configuration dictionary in-memory.
Creates a global configuration that can be accessed by other portions of the code via `conf` or `config` function calls. Minimizes the need to create `Config` objects and pass them around different modules, classes, functions, etc.
```python
from toolbox import make_config
make_config(hello="world")
```
config — Access in-memory configuration as dictionary.
```python
from toolbox import config
print(config()['hello']) # 'world'
```
conf — Access in-memory configuration as nestednametuple.
```python
from toolbox import conf
print(conf().hello) # 'world'
```
### `functools`
timeout — Decorator to add timeout for synchronous and asychronous functions.
Decorator that adds support for synchronous and asynchronous function timeout. Quits function after an amount of time passes.
```python
from toolbox import timeout
import asyncio
import time
@timeout(seconds=1)
def func():
time.sleep(15)
@timeout(seconds=1)
async def func():
await asyncio.sleep(15)
```
### `pdb`
sprinkle — Prints the line and file that this function was just called from.
```python
from toolbox.pdb.sprinkle import sprinkle
sprinkle() # >>> 3 this_file.py
sprinkle("hello", "world") # >>> 4 this_file.py hello world
```
### `pkgutil`
search_package — Searches for packages installed in the system.
```python
from toolbox import search_package
print(search_package("toolbox", method="is"))
# {'toolbox': }
```
### `sockets`
is_ip — Checks if a string is an IP address.
```python
from toolbox import is_ip
print(is_ip('127.0.0.1')) # True
print(is_ip('localhost')) # False
```
### `string`
ANSI Formatting — Color formatting.
Check documentation [here](https://synchronizing.github.io/toolbox/module/string.html#color) for further information on all built-in formats.
```python
from toolbox import bold, red
print(red("This text is red!"))
print(bold("This text is bolded!"))
```
Format — Persistent ANSI formatter that takes a custom ANSI code.
```python
from toolbox import Format
bold = Format(code=1)
print(bold("hello world"))
```
Style — Persistent ANSI formatter that allows multiple ANSI codes.
```python
from toolbox import Style, red, bold
error = Style(red, bold)
print(error("This is red & bolded error."))
```
supports_color — Check's if the user's terminal supports color.
```python
from toolbox import supports_color
print(supports_color()) # True
```
strip_ansi — Removes ANSI codes from string.
```python
from toolbox import strip_ansi
print(strip_ansi("\x1b[1mhello world\x1b[0m")) # hello world
```
### `textwrap`
unindent — Removes indent and white-space from docstrings.
```python
from toolbox import unindent
def test():
text = """
hello world
this is a test
"""
print(text)
text = unindent(
"""
hello world
this is a test
"""
)
print(text)
test()
# hello world
# this is a test
#
# hello world
# this is a test
```
%package help
Summary: Development documents and examples for toolbox
Provides: python3-toolbox-doc
%description help
# 🧰 Toolbox
Toolbox is a small (~0.2MB) set of tools that expands the [Python Standard Library](https://docs.python.org/3/library/).
## Installing
```
pip install toolbox
```
## Documentation
Documentation can be found [**here**](http://synchronizing.github.io/toolbox/).
## Tools
### `asyncio`
future_lru_cache — lru_cache for async functions.
```python
from toolbox import future_lru_cache
import asyncio
@future_lru_cache
async def func():
await asyncio.sleep(10)
return 42
async def main():
await func() # Runs once.
await func() # Returns cached value.
asyncio.run(main())
````
to_thread — Run a synchronous function in a separate thread.
```python
from toolbox import to_thread
import asyncio
import time
def func():
time.sleep(2)
return "Hello world"
async def main():
await to_thread(func)
asyncio.run(main())
````
awaitable — Convert synchronous function to an async function via thread.
Leverages the `to_thread` function above.
```python
from toolbox import awaitable
import asyncio
import time
@awaitable
def func():
time.sleep(2)
return "Hello world"
async def main():
await func()
asyncio.run(func())
```
tls_handshake — Perform TLS handshake with a stream reader & writer.
```python
from toolbox import tls_handshake
import asyncio
async def client():
reader, writer = await asyncio.open_connection("httpbin.org", 443, ssl=False)
await tls_handshake(reader=reader, writer=writer)
# Communication is now encrypted.
asyncio.run(client())
```
CoroutineClass — Class pattern for implementing object-based coroutines.
Pattern for creating a coroutine-like class that has multiple ways to start it.
```python
from toolbox import CoroutineClass
import asyncio
class Coroutine(CoroutineClass):
def __init__(self, run: bool = False):
super().__init__(run=run)
# Default entry function.
async def entry(self):
await asyncio.sleep(1)
return "Hello world"
# Start coroutine outside Python async context.
def iomain():
# via __init__
coro = Coroutine(run=True)
print(coro.result) # Hello world
# via .run()
coro = Coroutine()
result = coro.run()
print(result) # Hello world
# Start coroutine inside Python async context.
async def aiomain():
# via __init__
coro = Coroutine(run=True)
await asyncio.sleep(1)
coro.stop()
print(coro.result) # None - because process was stopped before completion.
# via .run()
coro = Coroutine()
coro.run()
await asyncio.sleep(1)
result = coro.stop() # None - because coroutine was stopped before completion.
print(result) # Hello world
# via await
coro = Coroutine()
result = await coro # You can also start, and await later.
print(result) # Hello World
# via context manager
async with Coroutine() as coro:
result = await coro
print(result) # Hello World
```
### `builtins`
classproperty — Decorator for defining a method as a property and classmethod.
Allows access to computed class attributes.
```python
from toolbox import classproperty
class Animal:
@classproperty
def dog(cls):
return "whoof!"
print(Animal.dog) # 'whoof!'
```
### `collections`
Item — An interface for type-agnostic operations between different types.
```python
from toolbox import Item
item = Item(100)
print(item == b"100" == "100" == 100) # True
```
nestednamedtuple — Creates a nested namedtuple.
```python
from toolbox import nestednamedtuple
nt = nestednamedtuple({"hello": {"ola": "mundo"}})
print(nt) # namedtupled(hello=namedtupled(ola='mundo'))
print(nt.hello.ola) # mundo
```
fdict — Forces nestednamedtuple to not convert dict to namedtuple.
```python
from toolbox import nestednamedtuple, fdict
d = {"hello": "world"}
nt = nestednamedtuple({"forced": fdict(d), "notforced": d})
print(nt.notforced) # namedtupled(hello='world')
print(nt.forced) # {'hello': 'world'}
```
BidirectionalDict — Dictionary with two-way capabilities.
```python
from toolbox import BidirectionalDict
d = BidirectionalDict({"hello": "world"})
print(d) # {'hello': 'world', 'world': 'hello'}
```
ObjectDict — Dictionary that can be accessed as though it was an object.
```python
from toolbox import ObjectDict
d = ObjectDict({"hello": "world"})
print(d.hello) # 'world'
```
OverloadedDict — Dictionary that can be added or subtracted to.
```python
from toolbox import OverloadedDict
d1 = OverloadedDict({"hello": "world"})
d2 = OverloadedDict({"ola": "mundo"})
d1 += d2
print(d1) # {'hello': 'world', 'ola': 'mundo'}
d1 -= d2
print(d1) # {'hello': 'world'}
```
UnderscoreAccessDict — Dictionary with underscore access.
```python
from toolbox import UnderscoreAccessDict
d = UnderscoreAccessDict({"hello": "world"})
print(d.hello) # 'world'
```
FrozenDict — Dictionary that is frozen.
```python
from toolbox import FrozenDict
d = FrozenDict({"hello": "world"})
d["hello"] = "mundo" # KeyError: Cannot set key and value because this is a frozen dictionary.
```
MultiEntryDict — Dictionary that can have multiple entries for the same key.
```python
from toolbox import MultiEntryDict
d = MultiEntryDict({"hello": "world"})
d["hello"] = "mundo"
print(d) # {'hello': ['world', 'mundo']}
```
ItemDict — Dictionary that utilizes Item for key and values.
```python
from toolbox import ItemDict, Item
d = ItemDict({"100": "one hundred"})
print(d[100]) # one hundred
print(d[100] == d['100'] == d[b'100'] == d[Item(100)]) # True
```
All `*Dict` types above can be combined together (as mixins) to create unique dictionary types.
### `config`
make_config — Stores configuration dictionary in-memory.
Creates a global configuration that can be accessed by other portions of the code via `conf` or `config` function calls. Minimizes the need to create `Config` objects and pass them around different modules, classes, functions, etc.
```python
from toolbox import make_config
make_config(hello="world")
```
config — Access in-memory configuration as dictionary.
```python
from toolbox import config
print(config()['hello']) # 'world'
```
conf — Access in-memory configuration as nestednametuple.
```python
from toolbox import conf
print(conf().hello) # 'world'
```
### `functools`
timeout — Decorator to add timeout for synchronous and asychronous functions.
Decorator that adds support for synchronous and asynchronous function timeout. Quits function after an amount of time passes.
```python
from toolbox import timeout
import asyncio
import time
@timeout(seconds=1)
def func():
time.sleep(15)
@timeout(seconds=1)
async def func():
await asyncio.sleep(15)
```
### `pdb`
sprinkle — Prints the line and file that this function was just called from.
```python
from toolbox.pdb.sprinkle import sprinkle
sprinkle() # >>> 3 this_file.py
sprinkle("hello", "world") # >>> 4 this_file.py hello world
```
### `pkgutil`
search_package — Searches for packages installed in the system.
```python
from toolbox import search_package
print(search_package("toolbox", method="is"))
# {'toolbox': }
```
### `sockets`
is_ip — Checks if a string is an IP address.
```python
from toolbox import is_ip
print(is_ip('127.0.0.1')) # True
print(is_ip('localhost')) # False
```
### `string`
ANSI Formatting — Color formatting.
Check documentation [here](https://synchronizing.github.io/toolbox/module/string.html#color) for further information on all built-in formats.
```python
from toolbox import bold, red
print(red("This text is red!"))
print(bold("This text is bolded!"))
```
Format — Persistent ANSI formatter that takes a custom ANSI code.
```python
from toolbox import Format
bold = Format(code=1)
print(bold("hello world"))
```
Style — Persistent ANSI formatter that allows multiple ANSI codes.
```python
from toolbox import Style, red, bold
error = Style(red, bold)
print(error("This is red & bolded error."))
```
supports_color — Check's if the user's terminal supports color.
```python
from toolbox import supports_color
print(supports_color()) # True
```
strip_ansi — Removes ANSI codes from string.
```python
from toolbox import strip_ansi
print(strip_ansi("\x1b[1mhello world\x1b[0m")) # hello world
```
### `textwrap`
unindent — Removes indent and white-space from docstrings.
```python
from toolbox import unindent
def test():
text = """
hello world
this is a test
"""
print(text)
text = unindent(
"""
hello world
this is a test
"""
)
print(text)
test()
# hello world
# this is a test
#
# hello world
# this is a test
```
%prep
%autosetup -n toolbox-1.11.0
%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-toolbox -f filelist.lst
%dir %{python3_sitelib}/*
%files help -f doclist.lst
%{_docdir}/*
%changelog
* Wed May 10 2023 Python_Bot - 1.11.0-1
- Package Spec generated