passagemath-rubiks 10.6.46__cp310-cp310-macosx_13_0_arm64.whl

passagemath_rubiks/__init__.py

@@ -0,0 +1,3 @@
+# sage_setup: distribution = sagemath-rubiks
+
+from sage.all__sagemath_rubiks import *

passagemath_rubiks-10.6.46.dist-info/METADATA

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: passagemath-rubiks
+Version: 10.6.46
+Summary: passagemath: Algorithms for Rubik's cube
+Author-email: The Sage Developers <sage-support@googlegroups.com>
+Maintainer: Matthias Köppe, passagemath contributors
+License-Expression: GPL-2.0-or-later
+Project-URL: release notes, https://github.com/passagemath/passagemath/releases
+Project-URL: repo (upstream), https://github.com/sagemath/sage
+Project-URL: repo, https://github.com/passagemath/passagemath
+Project-URL: documentation, https://passagemath.org/docs/latest
+Project-URL: homepage (upstream), https://www.sagemath.org
+Project-URL: discourse, https://passagemath.discourse.group
+Project-URL: tracker (upstream), https://github.com/sagemath/sage/issues
+Project-URL: tracker, https://github.com/passagemath/passagemath/issues
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: <3.15,>=3.10
+Description-Content-Type: text/x-rst
+Provides-Extra: test
+Requires-Dist: passagemath-groups; extra == "test"
+Requires-Dist: passagemath-repl; extra == "test"
+
+===============================================================================
+passagemath: Algorithms for Rubik's cube
+===============================================================================
+
+`passagemath <https://github.com/passagemath/passagemath>`__ is open
+source mathematical software in Python, released under the GNU General
+Public Licence GPLv2+.
+
+It is a fork of `SageMath <https://www.sagemath.org/>`__, which has been
+developed 2005-2025 under the motto “Creating a Viable Open Source
+Alternative to Magma, Maple, Mathematica, and MATLAB”.
+
+The passagemath fork uses the motto "Creating a Free Passage Between the
+Scientific Python Ecosystem and Mathematical Software Communities."
+It was created in October 2024 with the following goals:
+
+-  providing modularized installation with pip,
+-  establishing first-class membership in the scientific Python
+   ecosystem,
+-  giving `clear attribution of upstream
+   projects <https://groups.google.com/g/sage-devel/c/6HO1HEtL1Fs/m/G002rPGpAAAJ>`__,
+-  providing independently usable Python interfaces to upstream
+   libraries,
+-  offering `platform portability and integration testing
+   services <https://github.com/passagemath/passagemath/issues/704>`__
+   to upstream projects,
+-  inviting collaborations with upstream projects,
+-  `building a professional, respectful, inclusive
+   community <https://groups.google.com/g/sage-devel/c/xBzaINHWwUQ>`__,
+-  `empowering Sage users to participate in the scientific Python ecosystem
+   <https://github.com/passagemath/passagemath/issues/248>`__ by publishing packages,
+-  developing a port to `Pyodide <https://pyodide.org/en/stable/>`__ for
+   serverless deployment with Javascript,
+-  developing a native Windows port.
+
+`Full documentation <https://passagemath.org/docs/latest/html/en/index.html>`__ is
+available online.
+
+passagemath attempts to support and provides binary wheels suitable for
+all major Linux distributions and recent versions of macOS.
+
+Binary wheels for native Windows (x86_64) are are available for a subset of
+the passagemath distributions. Use of the full functionality of passagemath
+on Windows currently requires the use of Windows Subsystem for Linux (WSL)
+or virtualization.
+
+The supported Python versions in the passagemath 10.6.x series are 3.10.x-3.14.x.
+
+
+About this pip-installable distribution package
+-----------------------------------------------
+
+This pip-installable distribution ``passagemath-rubiks`` provides an interface
+to several programs for working with Rubik's cubes.
+
+Michael Reid (GPL) http://www.cflmath.com/~reid/Rubik/optimal_solver.html
+
+-  optimal - uses many pre-computed tables to find an optimal
+   solution to the 3x3x3 Rubik's cube
+
+Dik T. Winter (MIT License)
+
+-  cube - uses Kociemba's algorithm to iteratively find a short
+   solution to the 3x3x3 Rubik's cube
+-  size222 - solves a 2x2x2 Rubik's cube
+
+Eric Dietz (GPL) https://web.archive.org/web/20121212175710/http://www.wrongway.org/?rubiksource
+
+-  cu2 - A fast, non-optimal 2x2x2 solver
+-  cubex - A fast, non-optimal 3x3x3 solver
+-  mcube - A fast, non-optimal 4x4x4 solver
+
+
+What is included
+----------------
+
+* `Interface <https://passagemath.org/docs/latest/html/en/reference/interfaces/sage/interfaces/rubik.html#module-sage.interfaces.rubik>`_
+
+* `Features <https://passagemath.org/docs/latest/html/en/reference/spkg/sage/features/rubiks.html#module-sage.features.rubiks>`_ (via passagemath-environment)
+
+* Binary wheels on PyPI contain prebuilt copies of rubiks executables.
+
+
+Examples
+--------
+
+Using rubiks programs on the command line::
+
+    $ pipx run --pip-args="--prefer-binary" --spec "passagemath-rubiks" sage -sh -c cubex
+
+
+Finding the installation location of a rubiks program::
+
+    $ pipx run --pip-args="--prefer-binary" --spec "passagemath-rubiks[test]" ipython
+
+    In [1]: from sage.features.rubiks import cubex
+
+    In [2]: cubex().absolute_filename()
+
+
+Using the Python interface::
+
+    $ pipx run --pip-args="--prefer-binary" --spec "passagemath-rubiks[test]" ipython
+
+    In [1]: from sage.interfaces.rubik import *
+
+    In [2]: C = RubiksCube("R U F L B D")
+
+    In [3]: sol = CubexSolver().solve(C.facets()); sol
+    Out[3]: "U' L' L' U L U' L U D L L D' L' D L' D' L D L' U' L D' L' U L' B' U' L' U B L D L D' U' L' U L B L B' L' U L U' L' F' L' F L' F L F' L' D' L' D D L D' B L B' L B' L B F' L F F B' L F' B D' D' L D B' B' L' D' B U' U' L' B' D' F' F' L D F'"
+
+
+Using sage.groups.perm_gps::
+
+    $ pipx run --pip-args="--prefer-binary" --spec "passagemath-rubiks[test]" ipython
+
+    In [1]: from passagemath_rubiks import *
+
+    In [2]: rubik = CubeGroup(); state = rubik.faces("R")
+
+    In [3]: rubik.solve(state)
+    Out[3]: 'R'

passagemath_rubiks-10.6.46.dist-info/RECORD

@@ -0,0 +1,17 @@
+passagemath_rubiks-10.6.46.dist-info/RECORD,,
+passagemath_rubiks-10.6.46.dist-info/WHEEL,sha256=NiDEgsEgCo_FQMmjOAqM82taU_S298AgeyCKlTR6Sr8,153
+passagemath_rubiks-10.6.46.dist-info/top_level.txt,sha256=FMgD4ZM3GVwb20o5Ad_LYdWrdFM10nZnrN71URGfQGs,25
+passagemath_rubiks-10.6.46.dist-info/METADATA,sha256=1VPOyNmd-tO2-slCa8mnSYtQ5z-rbczn5xXLR1nU9eM,6408
+sage_wheels/bin/cubex,sha256=9QzXdnXBoUUq39uX-wN9zOuISyGJZtM3Hkij2ARDSCQ,249448
+sage_wheels/bin/cu2,sha256=eUM51DdbCJCUj3T5DAESek2fyEcJ71xpBm5jfNdIeOY,184144
+sage_wheels/bin/mcube,sha256=lTlhFR42H1D04r3obP92iGVmZWAkL0o5iNIh7uxxwSI,289800
+sage_wheels/bin/optimal,sha256=5uKTXneREsfLZrNCBDLWUb8Y-ihEolmTEleM5mSo2Uk,104232
+sage_wheels/bin/dikcube,sha256=slwcJDQTgFEY04r1sUFyiaekY9QLPK8spoDu_cPJBow,69208
+sage_wheels/bin/size222,sha256=7mUPVlbHJqollcOziA0H8mPAaCawUJIeeGyOXyVcxFA,50856
+passagemath_rubiks/__init__.py,sha256=s6SS1hH2ZcoBAPlMHrjl6elW0Rw8CBEGeMubfQUNcPI,86
+sage/all__sagemath_rubiks.py,sha256=7mJ-YvWC9PY9BQD0fF_sUu1YDlEceafc2oHrl-uKLK0,106
+sage/libs/all__sagemath_rubiks.py,sha256=NwzyxDmQ4ARkr80f2jCvoIx0PgxV4ST30myyuf6PIC8,45
+sage/libs/rubik.pyx,sha256=NwzyxDmQ4ARkr80f2jCvoIx0PgxV4ST30myyuf6PIC8,45
+sage/libs/rubik.cpython-310-darwin.so,sha256=6ZPeIBiwNALP1fH5W60VuNkbzOWaNiHDtxENG1XTGBM,53784
+sage/interfaces/all__sagemath_rubiks.py,sha256=C8lJV2QqUEHE1a50uaQHU7lCVmgfCQ0Io4ZP9_S2J5o,169
+sage/interfaces/rubik.py,sha256=V5T8iXOcrnYIhOCo_JPwmrF01IbpeipAoNWHcHHx6zQ,11794

passagemath_rubiks-10.6.46.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp310-cp310-macosx_13_0_arm64
+Generator: delocate 0.13.1.dev42+ga0af70b54
+

passagemath_rubiks-10.6.46.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+
+passagemath_rubiks
+sage

sage/all__sagemath_rubiks.py

@@ -0,0 +1,4 @@
+# sage_setup: distribution = sagemath-rubiks
+# delvewheel: patch
+
+from sage.all__sagemath_groups import *

sage/interfaces/all__sagemath_rubiks.py

@@ -0,0 +1,8 @@
+# sage_setup: distribution = sagemath-rubiks
+
+from sage.all__sagemath_categories import *
+
+try:
+    from sage.all__sagemath_groups import *
+except ImportError:
+    pass

sage/interfaces/rubik.py

@@ -0,0 +1,341 @@
+# sage_setup: distribution = sagemath-rubiks
+# sage.doctest: optional - rubiks
+r"""
+Interface to several Rubik's cube solvers.
+
+The first is by Michael Reid, and tries to find an optimal solution given
+the cube's state, and may take a long time.
+See http://www.math.ucf.edu/~reid/Rubik/optimal_solver.html
+
+The second is by Eric Dietz, and uses a standard (?) algorithm to
+solve the cube one level at a time. It is extremely fast, but often
+returns a far from optimal solution.
+See https://web.archive.org/web/20121212175710/http://www.wrongway.org/?rubiksource
+
+The third is by Dik Winter and implements Kociemba's algorithm which
+finds reasonable solutions relatively quickly, and if it is kept running
+will eventually find the optimal solution.
+
+AUTHOR:
+
+   -- Optimal was written by Michael Reid <reid@math.ucf.edu> (2004)
+   -- Cubex was written by Eric Dietz <root@wrongway.org> (2003)
+   -- Kociemba was written by Dik T. Winter <dik.winter@cwi.nl> (1993)
+   -- Initial interface by Robert Bradshaw (2007-08)
+"""
+
+########################################################################
+#   Copyright (C) 2007 Robert Bradshaw <robertwb@math.washington.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#  The full text of the GPL is available at:
+#
+#                  https://www.gnu.org/licenses/
+########################################################################
+
+import pexpect
+import time
+import shlex
+
+from . import quit
+
+from sage.cpython.string import bytes_to_str
+from sage.groups.perm_gps.cubegroup import index2singmaster
+import sage.features.rubiks
+
+
+# Can't seem to find consistency in letter ordering
+# between us and them... These are copied from the source.
+optimal_solver_tokens = ["UF", "UR", "UB", "UL",
+                         "DF", "DR", "DB", "DL",
+                         "FR", "FL", "BR", "BL",
+                         "FU", "RU", "BU", "LU",
+                         "FD", "RD", "BD", "LD",
+                         "RF", "LF", "RB", "LB",
+                         "UFR", "URB", "UBL", "ULF",
+                         "DRF", "DFL", "DLB", "DBR",
+                         "FRU", "RBU", "BLU", "LFU",
+                         "RFD", "FLD", "LBD", "BRD",
+                         "RUF", "BUR", "LUB", "FUL",
+                         "FDR", "LDF", "BDL", "RDB"]
+
+# The input format.
+optimal_solver_format = "UF UR UB UL DF DR DB DL FR FL BR BL UFR URB UBL ULF DRF DFL DLB DBR"
+
+
+class SingNot:
+    """
+    This class is to resolve difference between various Singmaster notation.
+
+    Case is ignored, and the second and third letters may be swapped.
+
+    EXAMPLES::
+
+        sage: from sage.interfaces.rubik import SingNot
+        sage: SingNot("acb") == SingNot("ACB")
+        True
+        sage: SingNot("acb") == SingNot("bca")
+        False
+    """
+    def __init__(self, s):
+        self.rep = s
+        self.canonical = (s[0] + "".join(sorted(s[1:]))).lower()
+
+    def __eq__(self, other):
+        return isinstance(other, SingNot) and other.canonical == self.canonical
+
+    def __repr__(self):
+        return self.rep
+
+    def __hash__(self):
+        return hash(self.canonical)
+
+
+# This is our list
+singmaster_list = [''] + [SingNot(index2singmaster(i + 1)) for i in range(48)]
+
+
+class OptimalSolver:
+    """
+    Interface to Michael Reid's optimal Rubik's Cube solver.
+    """
+    def __init__(self, verbose=False, wait=True):
+        self.verbose = verbose
+        self.start()
+        if wait:
+            print("Initializing tables...")
+            self.ready()
+            print("Done.")
+
+    def start(self):
+        cmd = shlex.quote(sage.features.rubiks.optimal().absolute_filename())
+        child = pexpect.spawn(cmd)
+        quit.register_spawned_process(child.pid, cmd)
+        child.timeout = None
+        self.child = child
+        self._ready = False
+
+    def stop(self):
+        if self.child:
+            self.child.sendline(chr(3))  # send ctrl-c
+            self.child.sendline(chr(4))  # send ctrl-d
+            self.child.close(True)
+            self.child = None
+
+    def ready(self):
+        if not self._ready:
+            self.child.expect('enter cube')
+            self._ready = True
+
+    def __call__(self, facets):
+        return self.solve(facets)
+
+    def solve(self, facets):
+        """
+        The initial startup and precomputation are substantial...
+
+        .. TODO:: Let it keep searching once it found a solution?
+
+        EXAMPLES::
+
+            sage: # optional - rubiks
+            sage: from sage.interfaces.rubik import *
+            sage: solver = DikSolver()
+            sage: solver = OptimalSolver()      # long time (28s on sage.math, 2012)
+            Initializing tables...
+            Done.
+            sage: C = RubiksCube("R U")
+            sage: solver.solve(C.facets())
+            'R  U'
+            sage: C = RubiksCube("R U F L B D")
+            sage: solver.solve(C.facets())
+            'R  U  F  L  B  D'
+            sage: C = RubiksCube("R2 D2")
+            sage: solver.solve(C.facets())
+            'R2 D2'
+        """
+        self.ready()
+        self.child.sendline(self.format_cube(facets))
+        self.child.expect(r"([LRUDBF'2 ]+)\s+\((\d+)q\*?, (\d+)f\*?\)")
+        self.child.sendline(chr(3))  # send ctrl-c
+        return bytes_to_str(self.child.match.groups()[0]).strip()
+
+    def format_cube(self, facets):
+        L = []
+        optimal_solver_list = [SingNot(x) for x in optimal_solver_tokens]
+        for f in optimal_solver_format.split(" "):
+            ix = facets[singmaster_list.index(SingNot(f)) - 1]
+            facet = singmaster_list[ix]
+            L.append(optimal_solver_list[optimal_solver_list.index(facet)])
+        return " ".join(str(f) for f in L)
+
+
+move_map = {
+    "LD": "L'",
+    "LU": "L",
+    "RD": "R",
+    "RU": "R'",
+    "FA": "F",
+    "FC": "F'",
+    "BA": "B'",
+    "BC": "B",
+    "UR": "U",
+    "UL": "U'",
+    "DR": "D'",
+    "DL": "D"
+}
+
+
+class CubexSolver:
+
+    def __call__(self, facets):
+        return self.solve(facets)
+
+    def solve(self, facets):
+        """
+        EXAMPLES::
+
+            sage: # optional - rubiks
+            sage: from sage.interfaces.rubik import *
+            sage: C = RubiksCube("R U")
+            sage: CubexSolver().solve(C.facets())
+            'R U'
+            sage: C = RubiksCube("R U F L B D")
+            sage: sol = CubexSolver().solve(C.facets()); sol
+            "U' L' L' U L U' L U D L L D' L' D L' D' L D L' U' L D' L' U L' B' U' L' U B L D L D' U' L' U L B L B' L' U L U' L' F' L' F L' F L F' L' D' L' D D L D' B L B' L B' L B F' L F F B' L F' B D' D' L D B' B' L' D' B U' U' L' B' D' F' F' L D F'"
+            sage: RubiksCube(sol) == C
+            True
+            sage: C = RubiksCube("R2 F'")
+            sage: CubexSolver().solve(C.facets())
+            "R' R' F'"
+            sage: C = RubiksCube().scramble()
+            sage: sol = CubexSolver().solve(C.facets())
+            sage: C == RubiksCube(sol)
+            True
+        """
+        s = self.format_cube(facets)
+        cmd = shlex.quote(sage.features.rubiks.cubex().absolute_filename()) + " " + s
+        child = pexpect.spawn(cmd)
+        ix = child.expect(['210.*?:', r'^5\d+(.*)'])
+        if ix == 0:
+            child.expect(['211', pexpect.EOF])
+            moves = bytes_to_str(child.before).strip().replace(',', '').split(' ')
+            return " ".join(move_map[m] for m in reversed(moves))
+        else:
+            s = child.after
+            while child.expect([r'^5\d+', pexpect.EOF]) == 0:
+                s += child.after
+            raise ValueError(bytes_to_str(s))
+
+    def format_cube(self, facets):
+        colors = sum([[i]*8 for i in range(1, 7)], [])
+        facet_colors = [0] * 54
+        for i in range(48):
+            f = facets[i]-1
+            f += (f + 4) // 8  # to compensate for the centers
+            facet_colors[f] = colors[i]
+        for i in range(6):
+            facet_colors[i*9+4] = i+1
+        return "".join(str(c) for c in facet_colors)
+
+
+class DikSolver:
+
+    def __call__(self, facets):
+        return self.solve(facets)
+
+    def solve(self, facets, timeout=10, extra_time=2):
+        """
+        EXAMPLES::
+
+            sage: # optional - rubiks
+            sage: from sage.interfaces.rubik import *
+            sage: C = RubiksCube().move("R U")
+            sage: DikSolver().solve(C.facets())
+            'R U'
+            sage: C = RubiksCube().move("R U F L B D")
+            sage: DikSolver().solve(C.facets())
+            'R U F L B D'
+            sage: C = RubiksCube().move("R2 F'")
+            sage: DikSolver().solve(C.facets())
+            "R2 F'"
+        """
+        cube_str = self.format_cube(facets)
+        cmd = shlex.quote(sage.features.rubiks.dikcube().absolute_filename()) + " -p"
+        child = pexpect.spawn(cmd)
+        child.expect('Initialization done!')
+        child.sendline(cube_str)
+
+        # We use send(chr(4)) instead of sendeof in this case, since
+        # child.sendoef() when run in the background with the Dik solver
+        # sends a SIGTTOU which suspends the process -- this is very bad.
+        # This is only a temporary workaround, and does not fix the problem
+        # on OS X.  The Dik C program itself will need to be fixed.
+        # See trac #1683. (TODO)      -- willem jp, wstein, mabshoff
+        child.send(chr(4))
+        # child.sendeof()
+
+        ix = child.expect(['Solution[^\n]*:', pexpect.EOF, pexpect.TIMEOUT], timeout=timeout)
+        if ix == 0:
+            child.expect(['[^\n]+'])
+            sol = child.after.strip()
+            start_time = time.time()
+            while extra_time > time.time() - start_time:
+                ix = child.expect(['Solution[^\n]*:', pexpect.EOF, pexpect.TIMEOUT], timeout=extra_time - int(time.time() - start_time))
+                if ix == 0:
+                    child.expect(['[^\n]+'])
+                    sol = child.after.strip()
+                else:
+                    extra_time = 0
+            # format the string into our notation
+            child.close(True)
+            sol = bytes_to_str(sol)
+            return ' '.join(self.rot_map[m[0]] + str(4 - int(m[1]))
+                            for m in reversed(sol.split(' '))).replace('1', '').replace('3', "'")
+        elif ix == 1:
+            # invalid format
+            child.close(True)
+            raise ValueError(bytes_to_str(child.before))
+        else:
+            child.close(True)
+            raise RuntimeError("timeout")
+
+    def format_cube(self, facets):
+        colors = sum([[i] * 8 for i in range(1, 7)], [])
+        facet_colors = [0] * 54
+        for i in range(48):
+            f = self.facet_map.index(facets[i])
+            facet_colors[f] = colors[i]
+        # now do the centers
+        facet_colors[4] = 1
+        facet_colors[49] = 6
+        for i in range(2, 6):
+            facet_colors[16 + i * 3] = i
+        return "".join(str(c) for c in facet_colors)
+
+    facet_map = [      1,  2,  3,
+                       4,  0,  5,
+                       6,  7,  8,
+           9, 10, 11, 17, 18, 19, 25, 26, 27, 33, 34, 35,
+          12,  0, 13, 20,  0, 21, 28,  0, 29, 36,  0, 37,
+          14, 15, 16, 22, 23, 24, 30, 31, 32, 38, 39, 40,
+                      41, 42, 43,
+                      44,  0, 45,
+                      46, 47, 48,
+            ]
+
+    # to compensate for different face naming
+    rot_map = dict(zip("BLURDF", "ULFRBD"))
+
+#    facet_map = [
+#                      1,  2,  3,
+#                      4,      6,
+#                      7,  8,  9,
+#          10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+#          23,     25, 26,     28,     29, 30, 31,     33,
+#          34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
+#                      46, 47, 48,
+#                      49,     51,
+#                      52, 53, 54,
+#    ]

sage/libs/all__sagemath_rubiks.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-rubiks

sage/libs/rubik.pyx

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-rubiks