diff options
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | python-permuta.spec | 600 | ||||
| -rw-r--r-- | sources | 1 |
3 files changed, 602 insertions, 0 deletions
@@ -0,0 +1 @@ +/permuta-2.2.0.tar.gz diff --git a/python-permuta.spec b/python-permuta.spec new file mode 100644 index 0000000..101bc9f --- /dev/null +++ b/python-permuta.spec @@ -0,0 +1,600 @@ +%global _empty_manifest_terminate_build 0 +Name: python-permuta +Version: 2.2.0 +Release: 1 +Summary: A comprehensive high performance permutation library. +License: BSD-3 +URL: https://github.com/PermutaTriangle/Permuta +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/80/6a/f4e241c4aaf7d13cbc4d14c40f9f976104742fe3b262cd5b6fcee3c0c7b0/permuta-2.2.0.tar.gz +BuildArch: noarch + + +%description +To install Permuta on your system, run: + pip install permuta +It is also possible to install Permuta in development mode to work on the +source code, in which case you run the following after cloning the repository: + ./setup.py develop +To run the unit tests: + pip install -r test_requirements.txt + ./setup.py test +Using Permuta +############# +Once you've installed Permuta, it can be imported by a Python script or an +interactive Python session, just like any other Python library: + >>> from permuta import * +Importing ``*`` from it supplies you with the 'Perm' and 'PermSet' +classes along with the 'AvoidanceClass' class (with alias 'Av') for generating +perms avoiding a set of patterns. It also gives you the 'MeshPatt' class +and some other submodules which we will not discuss in this readme. +Creating a single perm +###################### +Permutations are zero-based in Permuta and can be created using any iterable. + >>> Perm() # Empty perm + Perm(()) + >>> Perm([]) # Another empty perm + Perm(()) + >>> Perm((0, 1, 2, 3)) # The zero-based version of 1234 + Perm((0, 1, 2, 3)) + >>> Perm((2, 1, 3)) # Warning: it will initialise with any iterable + Perm((2, 1, 3)) +Permutations can also be created using some specific class methods. + >>> Perm.from_string("201") # strings + Perm((2, 0, 1)) + >>> Perm.one_based((1, 3, 2, 4)) # one-based iterable of integers + Perm((0, 2, 1, 3)) + >>> Perm.to_standard("a2gsv3") # standardising any iterable using '<' + Perm((2, 0, 3, 4, 5, 1)) + >>> Perm.from_integer(210) # an integer between 0 and 9876543210 + Perm((2, 1, 0)) + >>> Perm.from_integer(321) # any integer given is standardised + Perm((2, 1, 0)) + >>> Perm.from_integer(201) + Perm((2, 0, 1)) +Printing perms gives zero-based strings. + >>> print(Perm(())) + ε + >>> print(Perm((2, 1, 0))) + 210 + >>> print(Perm((6, 2, 10, 9, 3, 8, 0, 1, 5, 11, 4, 7))) + (6)(2)(10)(9)(3)(8)(0)(1)(5)(11)(4)(7) +The avoids, contains, and occurrence methods enable working with patterns: + >>> p = Perm((0,2,1,3)) + >>> p.contains(Perm((2, 1, 0))) + False + >>> p.avoids(Perm((0, 1))) + False + >>> list(p.occurrences_of(Perm((1, 0)))) + [(1, 2)] + >>> list(Perm((0, 1)).occurrences_in(p)) + [(0, 1), (0, 2), (0, 3), (1, 3), (2, 3)] +The basic symmetries are implemented: + >>> [p.reverse(), p.complement(), p.inverse()] + [Perm((3, 1, 2, 0)), Perm((3, 1, 2, 0)), Perm((0, 2, 1, 3))] +To take direct sums and skew sums we use ``+`` and ``-``: + >>> q = Perm((0, 1, 2, 3, 4)) + >>> p + q + Perm((0, 2, 1, 3, 4, 5, 6, 7, 8)) + >>> p - q + Perm((5, 7, 6, 8, 0, 1, 2, 3, 4)) +There are numerous practical methods available: + >>> list(p.fixed_points()) + [0, 3] + >>> list(p.ascents()) + [0, 2] + >>> list(p.descents()) + [1] + >>> list(p.inversions()) + [(1, 2)] + >>> p.major_index() + 2 +Creating a perm class +##################### +Perm classes are specified with a basis: + >>> basis = Basis(Perm((1, 0, 2)), Perm((1, 2, 0))) + >>> basis + Basis((Perm((1, 0, 2)), Perm((1, 2, 0)))) + >>> perm_class = Av(basis) + >>> perm_class + Av(Basis((Perm((1, 0, 2)), Perm((1, 2, 0))))) +You can ask whether a perm belongs to the perm class: + >>> Perm((3, 2, 1, 0)) in perm_class + True + >>> Perm((0, 2, 1, 3)) in perm_class + False +You can get its enumeration up to a fixed length. + >>> perm_class.enumeration(10) + [1, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512] + >>> perm_class.count(11) + 1024 +You can also look to see if some well know enumeration strategies apply to a +given class. + >>> from permuta.enumeration_strategies import find_strategies + >>> basis = [Perm((3, 2, 0, 1)), Perm((1, 0, 2, 3))] + >>> for strat in find_strategies(basis): + The insertion encoding of permutations: Corollary 10 + >>> basis = [Perm((1, 2, 0, 3)), Perm((2, 0, 1, 3)), Perm((0, 1, 2, 3))] + >>> for strat in find_strategies(basis): + Enumeration of Permutation Classes and Weighted Labelled Independent Sets: Corollary 4.3 +Permutation statistics +###################### +With the ``PermutationStatistic`` class we can look for distributions of statistics for +classes and look for statistics preservations (or transformation) either for two classes +or given a bijection. First we need to import it. + >>> from permuta.permutils.statistics import PermutationStatistic +To see a distribution for a given statistic we grab its instance and provide a length +and a class (no class will use the set of all permutations). + >>> PermutationStatistic.show_predefined_statistics() # Show all statistics with id + [0] Number of inversions + [1] Number of non-inversions + [2] Major index + [3] Number of descents + [4] Number of ascents + [5] Number of peaks + [6] Number of valleys + [7] Number of cycles + [8] Number of left-to-right minimas + [9] Number of left-to-right maximas + [10] Number of right-to-left minimas + [11] Number of right-to-left maximas + [12] Number of fixed points + [13] Order + [14] Longest increasing subsequence + [15] Longest decreasing subsequence + [16] Depth + [17] Number of bounces + [18] Maximum drop size + [19] Number of primes in the column sums + [20] Holeyness of a permutation + [21] Number of stack-sorts needed + [22] Number of pop-stack-sorts needed + [23] Number of pinnacles + [24] Number of cyclic peaks + [25] Number of cyclic valleys + [26] Number of double excedance + [27] Number of double drops + [28] Number of foremaxima + [29] Number of afterminima + [30] Number of aftermaxima + [31] Number of foreminima + >>> depth = PermutationStatistic.get_by_index(16) + >>> depth.distribution_for_length(5) + [1, 4, 12, 24, 35, 24, 20] + >>> depth.distribution_up_to(4, Av.from_string("123")) + [[1], [1], [1, 1], [0, 2, 3], [0, 0, 3, 7, 4]] +Given a bijection as a dictionary, we can check which statistics are preserved with +``check_all_preservations`` and which are transformed with ``check_all_transformed`` + >>> bijection = {p: p.reverse() for p in Perm.up_to_length(5)} + >>> for stat in PermutationStatistic.check_all_preservations(bijection): + Number of peaks + Number of valleys + Holeyness of a permutation + Number of pinnacles +We can find all (predefined) statistics equally distributed over two permutation +classes with ``equally_distributed``. We also support checks for joint distribution +of more than one statistics with ``jointly_equally_distributed`` and transformation +of jointly distributed stats with ``jointly_transformed_equally_distributed``. + >>> cls1 = Av.from_string("2143,415263") + >>> cls2 = Av.from_string("3142") + >>> for stat in PermutationStatistic.equally_distributed(cls1, cls2, 6): + Major index + Number of descents + Number of ascents + Number of peaks + Number of valleys + Number of left-to-right minimas + Number of right-to-left maximas + Longest increasing subsequence + Longest decreasing subsequence + Number of pinnacles + +%package -n python3-permuta +Summary: A comprehensive high performance permutation library. +Provides: python-permuta +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-permuta +To install Permuta on your system, run: + pip install permuta +It is also possible to install Permuta in development mode to work on the +source code, in which case you run the following after cloning the repository: + ./setup.py develop +To run the unit tests: + pip install -r test_requirements.txt + ./setup.py test +Using Permuta +############# +Once you've installed Permuta, it can be imported by a Python script or an +interactive Python session, just like any other Python library: + >>> from permuta import * +Importing ``*`` from it supplies you with the 'Perm' and 'PermSet' +classes along with the 'AvoidanceClass' class (with alias 'Av') for generating +perms avoiding a set of patterns. It also gives you the 'MeshPatt' class +and some other submodules which we will not discuss in this readme. +Creating a single perm +###################### +Permutations are zero-based in Permuta and can be created using any iterable. + >>> Perm() # Empty perm + Perm(()) + >>> Perm([]) # Another empty perm + Perm(()) + >>> Perm((0, 1, 2, 3)) # The zero-based version of 1234 + Perm((0, 1, 2, 3)) + >>> Perm((2, 1, 3)) # Warning: it will initialise with any iterable + Perm((2, 1, 3)) +Permutations can also be created using some specific class methods. + >>> Perm.from_string("201") # strings + Perm((2, 0, 1)) + >>> Perm.one_based((1, 3, 2, 4)) # one-based iterable of integers + Perm((0, 2, 1, 3)) + >>> Perm.to_standard("a2gsv3") # standardising any iterable using '<' + Perm((2, 0, 3, 4, 5, 1)) + >>> Perm.from_integer(210) # an integer between 0 and 9876543210 + Perm((2, 1, 0)) + >>> Perm.from_integer(321) # any integer given is standardised + Perm((2, 1, 0)) + >>> Perm.from_integer(201) + Perm((2, 0, 1)) +Printing perms gives zero-based strings. + >>> print(Perm(())) + ε + >>> print(Perm((2, 1, 0))) + 210 + >>> print(Perm((6, 2, 10, 9, 3, 8, 0, 1, 5, 11, 4, 7))) + (6)(2)(10)(9)(3)(8)(0)(1)(5)(11)(4)(7) +The avoids, contains, and occurrence methods enable working with patterns: + >>> p = Perm((0,2,1,3)) + >>> p.contains(Perm((2, 1, 0))) + False + >>> p.avoids(Perm((0, 1))) + False + >>> list(p.occurrences_of(Perm((1, 0)))) + [(1, 2)] + >>> list(Perm((0, 1)).occurrences_in(p)) + [(0, 1), (0, 2), (0, 3), (1, 3), (2, 3)] +The basic symmetries are implemented: + >>> [p.reverse(), p.complement(), p.inverse()] + [Perm((3, 1, 2, 0)), Perm((3, 1, 2, 0)), Perm((0, 2, 1, 3))] +To take direct sums and skew sums we use ``+`` and ``-``: + >>> q = Perm((0, 1, 2, 3, 4)) + >>> p + q + Perm((0, 2, 1, 3, 4, 5, 6, 7, 8)) + >>> p - q + Perm((5, 7, 6, 8, 0, 1, 2, 3, 4)) +There are numerous practical methods available: + >>> list(p.fixed_points()) + [0, 3] + >>> list(p.ascents()) + [0, 2] + >>> list(p.descents()) + [1] + >>> list(p.inversions()) + [(1, 2)] + >>> p.major_index() + 2 +Creating a perm class +##################### +Perm classes are specified with a basis: + >>> basis = Basis(Perm((1, 0, 2)), Perm((1, 2, 0))) + >>> basis + Basis((Perm((1, 0, 2)), Perm((1, 2, 0)))) + >>> perm_class = Av(basis) + >>> perm_class + Av(Basis((Perm((1, 0, 2)), Perm((1, 2, 0))))) +You can ask whether a perm belongs to the perm class: + >>> Perm((3, 2, 1, 0)) in perm_class + True + >>> Perm((0, 2, 1, 3)) in perm_class + False +You can get its enumeration up to a fixed length. + >>> perm_class.enumeration(10) + [1, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512] + >>> perm_class.count(11) + 1024 +You can also look to see if some well know enumeration strategies apply to a +given class. + >>> from permuta.enumeration_strategies import find_strategies + >>> basis = [Perm((3, 2, 0, 1)), Perm((1, 0, 2, 3))] + >>> for strat in find_strategies(basis): + The insertion encoding of permutations: Corollary 10 + >>> basis = [Perm((1, 2, 0, 3)), Perm((2, 0, 1, 3)), Perm((0, 1, 2, 3))] + >>> for strat in find_strategies(basis): + Enumeration of Permutation Classes and Weighted Labelled Independent Sets: Corollary 4.3 +Permutation statistics +###################### +With the ``PermutationStatistic`` class we can look for distributions of statistics for +classes and look for statistics preservations (or transformation) either for two classes +or given a bijection. First we need to import it. + >>> from permuta.permutils.statistics import PermutationStatistic +To see a distribution for a given statistic we grab its instance and provide a length +and a class (no class will use the set of all permutations). + >>> PermutationStatistic.show_predefined_statistics() # Show all statistics with id + [0] Number of inversions + [1] Number of non-inversions + [2] Major index + [3] Number of descents + [4] Number of ascents + [5] Number of peaks + [6] Number of valleys + [7] Number of cycles + [8] Number of left-to-right minimas + [9] Number of left-to-right maximas + [10] Number of right-to-left minimas + [11] Number of right-to-left maximas + [12] Number of fixed points + [13] Order + [14] Longest increasing subsequence + [15] Longest decreasing subsequence + [16] Depth + [17] Number of bounces + [18] Maximum drop size + [19] Number of primes in the column sums + [20] Holeyness of a permutation + [21] Number of stack-sorts needed + [22] Number of pop-stack-sorts needed + [23] Number of pinnacles + [24] Number of cyclic peaks + [25] Number of cyclic valleys + [26] Number of double excedance + [27] Number of double drops + [28] Number of foremaxima + [29] Number of afterminima + [30] Number of aftermaxima + [31] Number of foreminima + >>> depth = PermutationStatistic.get_by_index(16) + >>> depth.distribution_for_length(5) + [1, 4, 12, 24, 35, 24, 20] + >>> depth.distribution_up_to(4, Av.from_string("123")) + [[1], [1], [1, 1], [0, 2, 3], [0, 0, 3, 7, 4]] +Given a bijection as a dictionary, we can check which statistics are preserved with +``check_all_preservations`` and which are transformed with ``check_all_transformed`` + >>> bijection = {p: p.reverse() for p in Perm.up_to_length(5)} + >>> for stat in PermutationStatistic.check_all_preservations(bijection): + Number of peaks + Number of valleys + Holeyness of a permutation + Number of pinnacles +We can find all (predefined) statistics equally distributed over two permutation +classes with ``equally_distributed``. We also support checks for joint distribution +of more than one statistics with ``jointly_equally_distributed`` and transformation +of jointly distributed stats with ``jointly_transformed_equally_distributed``. + >>> cls1 = Av.from_string("2143,415263") + >>> cls2 = Av.from_string("3142") + >>> for stat in PermutationStatistic.equally_distributed(cls1, cls2, 6): + Major index + Number of descents + Number of ascents + Number of peaks + Number of valleys + Number of left-to-right minimas + Number of right-to-left maximas + Longest increasing subsequence + Longest decreasing subsequence + Number of pinnacles + +%package help +Summary: Development documents and examples for permuta +Provides: python3-permuta-doc +%description help +To install Permuta on your system, run: + pip install permuta +It is also possible to install Permuta in development mode to work on the +source code, in which case you run the following after cloning the repository: + ./setup.py develop +To run the unit tests: + pip install -r test_requirements.txt + ./setup.py test +Using Permuta +############# +Once you've installed Permuta, it can be imported by a Python script or an +interactive Python session, just like any other Python library: + >>> from permuta import * +Importing ``*`` from it supplies you with the 'Perm' and 'PermSet' +classes along with the 'AvoidanceClass' class (with alias 'Av') for generating +perms avoiding a set of patterns. It also gives you the 'MeshPatt' class +and some other submodules which we will not discuss in this readme. +Creating a single perm +###################### +Permutations are zero-based in Permuta and can be created using any iterable. + >>> Perm() # Empty perm + Perm(()) + >>> Perm([]) # Another empty perm + Perm(()) + >>> Perm((0, 1, 2, 3)) # The zero-based version of 1234 + Perm((0, 1, 2, 3)) + >>> Perm((2, 1, 3)) # Warning: it will initialise with any iterable + Perm((2, 1, 3)) +Permutations can also be created using some specific class methods. + >>> Perm.from_string("201") # strings + Perm((2, 0, 1)) + >>> Perm.one_based((1, 3, 2, 4)) # one-based iterable of integers + Perm((0, 2, 1, 3)) + >>> Perm.to_standard("a2gsv3") # standardising any iterable using '<' + Perm((2, 0, 3, 4, 5, 1)) + >>> Perm.from_integer(210) # an integer between 0 and 9876543210 + Perm((2, 1, 0)) + >>> Perm.from_integer(321) # any integer given is standardised + Perm((2, 1, 0)) + >>> Perm.from_integer(201) + Perm((2, 0, 1)) +Printing perms gives zero-based strings. + >>> print(Perm(())) + ε + >>> print(Perm((2, 1, 0))) + 210 + >>> print(Perm((6, 2, 10, 9, 3, 8, 0, 1, 5, 11, 4, 7))) + (6)(2)(10)(9)(3)(8)(0)(1)(5)(11)(4)(7) +The avoids, contains, and occurrence methods enable working with patterns: + >>> p = Perm((0,2,1,3)) + >>> p.contains(Perm((2, 1, 0))) + False + >>> p.avoids(Perm((0, 1))) + False + >>> list(p.occurrences_of(Perm((1, 0)))) + [(1, 2)] + >>> list(Perm((0, 1)).occurrences_in(p)) + [(0, 1), (0, 2), (0, 3), (1, 3), (2, 3)] +The basic symmetries are implemented: + >>> [p.reverse(), p.complement(), p.inverse()] + [Perm((3, 1, 2, 0)), Perm((3, 1, 2, 0)), Perm((0, 2, 1, 3))] +To take direct sums and skew sums we use ``+`` and ``-``: + >>> q = Perm((0, 1, 2, 3, 4)) + >>> p + q + Perm((0, 2, 1, 3, 4, 5, 6, 7, 8)) + >>> p - q + Perm((5, 7, 6, 8, 0, 1, 2, 3, 4)) +There are numerous practical methods available: + >>> list(p.fixed_points()) + [0, 3] + >>> list(p.ascents()) + [0, 2] + >>> list(p.descents()) + [1] + >>> list(p.inversions()) + [(1, 2)] + >>> p.major_index() + 2 +Creating a perm class +##################### +Perm classes are specified with a basis: + >>> basis = Basis(Perm((1, 0, 2)), Perm((1, 2, 0))) + >>> basis + Basis((Perm((1, 0, 2)), Perm((1, 2, 0)))) + >>> perm_class = Av(basis) + >>> perm_class + Av(Basis((Perm((1, 0, 2)), Perm((1, 2, 0))))) +You can ask whether a perm belongs to the perm class: + >>> Perm((3, 2, 1, 0)) in perm_class + True + >>> Perm((0, 2, 1, 3)) in perm_class + False +You can get its enumeration up to a fixed length. + >>> perm_class.enumeration(10) + [1, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512] + >>> perm_class.count(11) + 1024 +You can also look to see if some well know enumeration strategies apply to a +given class. + >>> from permuta.enumeration_strategies import find_strategies + >>> basis = [Perm((3, 2, 0, 1)), Perm((1, 0, 2, 3))] + >>> for strat in find_strategies(basis): + The insertion encoding of permutations: Corollary 10 + >>> basis = [Perm((1, 2, 0, 3)), Perm((2, 0, 1, 3)), Perm((0, 1, 2, 3))] + >>> for strat in find_strategies(basis): + Enumeration of Permutation Classes and Weighted Labelled Independent Sets: Corollary 4.3 +Permutation statistics +###################### +With the ``PermutationStatistic`` class we can look for distributions of statistics for +classes and look for statistics preservations (or transformation) either for two classes +or given a bijection. First we need to import it. + >>> from permuta.permutils.statistics import PermutationStatistic +To see a distribution for a given statistic we grab its instance and provide a length +and a class (no class will use the set of all permutations). + >>> PermutationStatistic.show_predefined_statistics() # Show all statistics with id + [0] Number of inversions + [1] Number of non-inversions + [2] Major index + [3] Number of descents + [4] Number of ascents + [5] Number of peaks + [6] Number of valleys + [7] Number of cycles + [8] Number of left-to-right minimas + [9] Number of left-to-right maximas + [10] Number of right-to-left minimas + [11] Number of right-to-left maximas + [12] Number of fixed points + [13] Order + [14] Longest increasing subsequence + [15] Longest decreasing subsequence + [16] Depth + [17] Number of bounces + [18] Maximum drop size + [19] Number of primes in the column sums + [20] Holeyness of a permutation + [21] Number of stack-sorts needed + [22] Number of pop-stack-sorts needed + [23] Number of pinnacles + [24] Number of cyclic peaks + [25] Number of cyclic valleys + [26] Number of double excedance + [27] Number of double drops + [28] Number of foremaxima + [29] Number of afterminima + [30] Number of aftermaxima + [31] Number of foreminima + >>> depth = PermutationStatistic.get_by_index(16) + >>> depth.distribution_for_length(5) + [1, 4, 12, 24, 35, 24, 20] + >>> depth.distribution_up_to(4, Av.from_string("123")) + [[1], [1], [1, 1], [0, 2, 3], [0, 0, 3, 7, 4]] +Given a bijection as a dictionary, we can check which statistics are preserved with +``check_all_preservations`` and which are transformed with ``check_all_transformed`` + >>> bijection = {p: p.reverse() for p in Perm.up_to_length(5)} + >>> for stat in PermutationStatistic.check_all_preservations(bijection): + Number of peaks + Number of valleys + Holeyness of a permutation + Number of pinnacles +We can find all (predefined) statistics equally distributed over two permutation +classes with ``equally_distributed``. We also support checks for joint distribution +of more than one statistics with ``jointly_equally_distributed`` and transformation +of jointly distributed stats with ``jointly_transformed_equally_distributed``. + >>> cls1 = Av.from_string("2143,415263") + >>> cls2 = Av.from_string("3142") + >>> for stat in PermutationStatistic.equally_distributed(cls1, cls2, 6): + Major index + Number of descents + Number of ascents + Number of peaks + Number of valleys + Number of left-to-right minimas + Number of right-to-left maximas + Longest increasing subsequence + Longest decreasing subsequence + Number of pinnacles + +%prep +%autosetup -n permuta-2.2.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-permuta -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Wed May 17 2023 Python_Bot <Python_Bot@openeuler.org> - 2.2.0-1 +- Package Spec generated @@ -0,0 +1 @@ +531c14a193fba5e4f8f87694c13f9d0a permuta-2.2.0.tar.gz |