%global _empty_manifest_terminate_build 0
Name:		python-optionloop
Version:	1.0.7
Release:	1
Summary:	Allows collapsing of nested for loops via dictionary iteration
License:	GPL
URL:		https://github.com/arghdos/optionLoop
Source0:	https://mirrors.aliyun.com/pypi/web/packages/cf/92/11854118751b4629e47f52464d48d873a923d13849631bd585f569325721/optionloop-1.0.7.tar.gz
BuildArch:	noarch


%description
|Anaconda-Server Badge|
Simple loop structure to iterate over all combinations of an
initializing dictionary
No longer will you need a million nested for-loops...
The optionloop works as follows:
First, initialize a dictionary with various keys and values, e.g.:
    d = {'doThingX' : [True, False], 'doThingY' : False,
            'thingZValue' : ['a', 'b', 1]}
Next create the option loop:
    oploop = optionloop(d)
Finally iterate and get your values:
    for state in oploop:
        doX = state['doThingX']
        doY = state['doThingY']
        zVal = state['thingZValue']
        f(doX, doY, zVal)
This is intended to replace an equivalent looping structure of:
    for doX in doThingX:
        for doY in doThingY:
            for zVal in thingZValue:
                f(doX, doY, zVal)
which quickly becomes cumbersome.
Also, option loops can be added to create even more complex looping
structures, e.g.:
    d1 = {'lang' : ['c'], 'doThingX' : [True, False]}
    d2 = {'lang' : ['fortran'], 'doThingX' : [True, False], 'doThingY' : [True, False]}
    oploop1 = optionloop(d1)
    oploop2 = optionloop(d2)
    oploop = oploop1 + oploop2
    for state in oploop:
is equivalent to:
    langs = ['c', 'fortran']
    doThingX = [True, False]
    doThingY = [True, False]
    for lang in langs:
        if lang == 'c':
            for doX in doThingX:
                f(lang, doX)
        elif lang == 'fortran':
            for doX in doThingX:
                for doY in doThingY:
                    f(lang, doX, doY)
Note, if the order of iteration matters an ordered dict can be used,
e.g.:
    d = OrderedDict()
    d['a'] = [False, True]
    d['b'] = [False]
    d['c'] = [1, 2, 3]
    oploop = optionloop(d)
    for state in oploop:
is equivalent to:
    for a in [False, True]:
        for b in [False]:
            for c in [1, 2, 3]:
Additionally, an option loop (or combination thereof) can be reset using
the copy interface:
    d1 = {'lang' : ['c'], 'doThingX' : [True, False]}
    oploop1 = optionloop(d1)
    # iterate through 1
    oploop2 = oploop1.copy()

%package -n python3-optionloop
Summary:	Allows collapsing of nested for loops via dictionary iteration
Provides:	python-optionloop
BuildRequires:	python3-devel
BuildRequires:	python3-setuptools
BuildRequires:	python3-pip
%description -n python3-optionloop
|Anaconda-Server Badge|
Simple loop structure to iterate over all combinations of an
initializing dictionary
No longer will you need a million nested for-loops...
The optionloop works as follows:
First, initialize a dictionary with various keys and values, e.g.:
    d = {'doThingX' : [True, False], 'doThingY' : False,
            'thingZValue' : ['a', 'b', 1]}
Next create the option loop:
    oploop = optionloop(d)
Finally iterate and get your values:
    for state in oploop:
        doX = state['doThingX']
        doY = state['doThingY']
        zVal = state['thingZValue']
        f(doX, doY, zVal)
This is intended to replace an equivalent looping structure of:
    for doX in doThingX:
        for doY in doThingY:
            for zVal in thingZValue:
                f(doX, doY, zVal)
which quickly becomes cumbersome.
Also, option loops can be added to create even more complex looping
structures, e.g.:
    d1 = {'lang' : ['c'], 'doThingX' : [True, False]}
    d2 = {'lang' : ['fortran'], 'doThingX' : [True, False], 'doThingY' : [True, False]}
    oploop1 = optionloop(d1)
    oploop2 = optionloop(d2)
    oploop = oploop1 + oploop2
    for state in oploop:
is equivalent to:
    langs = ['c', 'fortran']
    doThingX = [True, False]
    doThingY = [True, False]
    for lang in langs:
        if lang == 'c':
            for doX in doThingX:
                f(lang, doX)
        elif lang == 'fortran':
            for doX in doThingX:
                for doY in doThingY:
                    f(lang, doX, doY)
Note, if the order of iteration matters an ordered dict can be used,
e.g.:
    d = OrderedDict()
    d['a'] = [False, True]
    d['b'] = [False]
    d['c'] = [1, 2, 3]
    oploop = optionloop(d)
    for state in oploop:
is equivalent to:
    for a in [False, True]:
        for b in [False]:
            for c in [1, 2, 3]:
Additionally, an option loop (or combination thereof) can be reset using
the copy interface:
    d1 = {'lang' : ['c'], 'doThingX' : [True, False]}
    oploop1 = optionloop(d1)
    # iterate through 1
    oploop2 = oploop1.copy()

%package help
Summary:	Development documents and examples for optionloop
Provides:	python3-optionloop-doc
%description help
|Anaconda-Server Badge|
Simple loop structure to iterate over all combinations of an
initializing dictionary
No longer will you need a million nested for-loops...
The optionloop works as follows:
First, initialize a dictionary with various keys and values, e.g.:
    d = {'doThingX' : [True, False], 'doThingY' : False,
            'thingZValue' : ['a', 'b', 1]}
Next create the option loop:
    oploop = optionloop(d)
Finally iterate and get your values:
    for state in oploop:
        doX = state['doThingX']
        doY = state['doThingY']
        zVal = state['thingZValue']
        f(doX, doY, zVal)
This is intended to replace an equivalent looping structure of:
    for doX in doThingX:
        for doY in doThingY:
            for zVal in thingZValue:
                f(doX, doY, zVal)
which quickly becomes cumbersome.
Also, option loops can be added to create even more complex looping
structures, e.g.:
    d1 = {'lang' : ['c'], 'doThingX' : [True, False]}
    d2 = {'lang' : ['fortran'], 'doThingX' : [True, False], 'doThingY' : [True, False]}
    oploop1 = optionloop(d1)
    oploop2 = optionloop(d2)
    oploop = oploop1 + oploop2
    for state in oploop:
is equivalent to:
    langs = ['c', 'fortran']
    doThingX = [True, False]
    doThingY = [True, False]
    for lang in langs:
        if lang == 'c':
            for doX in doThingX:
                f(lang, doX)
        elif lang == 'fortran':
            for doX in doThingX:
                for doY in doThingY:
                    f(lang, doX, doY)
Note, if the order of iteration matters an ordered dict can be used,
e.g.:
    d = OrderedDict()
    d['a'] = [False, True]
    d['b'] = [False]
    d['c'] = [1, 2, 3]
    oploop = optionloop(d)
    for state in oploop:
is equivalent to:
    for a in [False, True]:
        for b in [False]:
            for c in [1, 2, 3]:
Additionally, an option loop (or combination thereof) can be reset using
the copy interface:
    d1 = {'lang' : ['c'], 'doThingX' : [True, False]}
    oploop1 = optionloop(d1)
    # iterate through 1
    oploop2 = oploop1.copy()

%prep
%autosetup -n optionloop-1.0.7

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

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

%changelog
* Thu Jun 08 2023 Python_Bot <Python_Bot@openeuler.org> - 1.0.7-1
- Package Spec generated