regina 7.4.1__cp314-cp314-macosx_10_13_x86_64.whl

regina/__init__.py

@@ -0,0 +1,192 @@
+# Regina - A Normal Surface Theory Calculator
+# Python Module Initialisation
+#
+# Copyright (c) 2003-2025, Ben Burton
+# For further details contact Ben Burton (bab@debian.org).
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as
+# published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# As an exception, when this program is distributed through (i) the
+# App Store by Apple Inc.; (ii) the Mac App Store by Apple Inc.; or
+# (iii) Google Play by Google Inc., then that store may impose any
+# digital rights management, device limits and/or redistribution
+# restrictions that are required by its terms of service.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+import sys, os
+from . import engine
+from .engine import *
+
+if 'sage' in sys.modules:
+    # Typing "from regina import *" should not override certain
+    # names. This always applies to the built-in "open".
+    #
+    # Also: the Sage preparser adds "Integer" and relies on the name
+    # being bound to a Sage integer. If we override it, Sage
+    # breaks in multiple ways.
+    #
+    # We skip names_to_avoid in __all__.
+    names_to_avoid = set(['open', 'Integer'])
+    __all__ = (
+        [ name for name in engine.__dict__.keys()
+          if not name in names_to_avoid and not name.startswith('_') ] +
+        [ 'reginaSetup' ])
+
+    # All additional sage-related setup should be placed within sageSetup.py.
+    from . import sageSetup
+    del sageSetup
+else:
+    # Typing "from regina import *" is not supposed to override the
+    # built-in "open".  To achieve this, we skip it in __all__.
+    __all__ = (
+        [ name for name in engine.__dict__.keys()
+          if name != 'open' and not name.startswith('_') ] +
+        [ 'reginaSetup' ])
+
+# In sageRegina, the census files are supplied differently.
+# Set the location here.
+try:
+    from .pyCensus import __path__ as _pyCensusPath
+    GlobalDirs.setDirs(
+        GlobalDirs.home(),
+        GlobalDirs.pythonModule(),
+        _pyCensusPath[0])
+except ImportError:
+    pass
+
+def reginaSetup(quiet = False, readline = True, banner = False,
+                snappyPath = True, namespace = None, builtinOpen = True):
+    """
+    Initialise a Regina python session.
+
+    Arguments:
+        quiet      : If true, suppress informative messages that would
+                     otherwise be written to standard output.  If an error
+                     occurs, details of the error will be written regardless.
+        readline   : If true, attempt to enable tab completion.
+        snappyPath : Applies to platforms where SnapPy might not be installed
+                     on the python path (e.g., macOS users with the SnapPy app
+                     bundle).  If true, this setup routine will (i) attempt
+                     to locate SnapPy, and (ii) if successful, extend sys.path
+                     to include the location of SnapPy's python module and its
+                     dependencies.
+        banner     : If true, print a welcome banner to standard output.
+        namespace  : The global namespace in which the start-up library scripts
+                     (if any) will be executed.  This may be None, in which
+                     case the caller's global namespace will be used.
+        builtinOpen: If true, sets "open" in the given namespace to Python's
+                     builtin open() function.  This is used to work around the
+                     problem whereby "from regina import *", overrides Python's
+                     open() function with Regina's.  You will still be able to
+                     access Regina's open() function by calling regina.open().
+                     If the namespace argument above is None, then this option
+                     has no effect.
+    """
+
+    if readline:
+        # Enable tab completion through readline, if we can.
+        try:
+            import rlcompleter, readline
+            # readline by default completes an empty string, whereas if 
+            # we press tab we want to insert an actual tab character, 
+            # so we have our own completion function.
+
+            __internal_python_completer = readline.get_completer()
+            def regina_completer(text, state):
+              if not text:
+                return ('\t', None)[state]
+              else:
+                return __internal_python_completer(text, state)
+            readline.set_completer(regina_completer)
+
+            if 'libedit' in readline.__doc__:
+                # Some systems work with libedit, not libreadline, which
+                # supports a different set of commands.
+                readline.parse_and_bind('bind ^I rl_complete')
+            else:
+                readline.parse_and_bind('tab: complete')
+        except:
+            pass
+
+    if snappyPath:
+        # For the time being, only find SnapPy on macOS.
+        if sys.platform == 'darwin':
+            if sys.version_info[:2] == (3, 8):
+                # Ask macOS where SnapPy lives.
+                import subprocess
+                try:
+                    app = subprocess.check_output(['mdfind',
+                        'kMDItemDisplayName==SnapPy&&kMDItemKind==Application'])
+                    if app:
+                        app = app.strip().split('\n')[0]
+                except:
+                    app = None
+
+                if not app:
+                    app = '/Applications/SnapPy.app'
+                snappyLib = app + '/Contents/Resources/lib/python3.8'
+                snappyZip = app + '/Contents/Resources/lib/python38.zip'
+                if os.path.exists(snappyLib):
+                    sys.path.append(snappyLib)
+                    sys.path.append(snappyLib + '/site-packages.zip')
+                    sys.path.append(snappyLib + '/lib-dynload')
+                if os.path.exists(snappyZip):
+                    sys.path.append(snappyZip)
+
+    if banner:
+        print(engine.welcome())
+
+    if builtinOpen and namespace:
+        namespace['open'] = __builtins__['open']
+
+def __execScript(namespace = None):
+    """
+    For internal use by regina-python.
+    Executes a given python script.
+
+    The filename of the script should be in sys.argv[1], and
+    any arguments to the script should be in sys.argv[2:].
+    However, ipython sets things up a little differently (it includes two
+    additional arguments), and we attempt to compensate for this here.
+
+    SIDE-EFFECT: sys.argv will be truncated to include the script and
+    its arguments only (i.e., sys.argv[0] will be removed).
+
+    Arguments:
+        namespace : The global namespace in which the script will be executed.
+                    This may be None, in which case the caller's global
+                    namespace will be used.
+    """
+
+    try:
+        __IPYTHON__
+        # Although python sets sys.argv = [ '-c', script, arg, ... ],
+        # ipython sets sys.argv as the full original command line:
+        #   [ ipython, '-c', command, script, arg, ... ], or
+        #   [ ipython, '-i', '-c', command, script, arg, ... ].
+        # Repair things here.
+        if len(sys.argv) >= 3 and sys.argv[1] == '-c':
+            sys.argv = [ '-c' ] + sys.argv[3:]
+        elif len(sys.argv) >= 4 and sys.argv[1:3] == ['-i', '-c']:
+            sys.argv = [ '-c' ] + sys.argv[4:]
+    except:
+        pass
+
+    script = __builtins__['open'](sys.argv[1]).read()
+    sys.argv = sys.argv[1:]
+    if namespace:
+        exec(script, namespace)
+    else:
+        exec(script)
+

regina/plainCompleter.py

@@ -0,0 +1,221 @@
+"""A copy of Python's rlcompleter module that removes all interaction
+with the readline module.  This is a trivial modification of rlcompleter.py
+from Python 3.9, which is licensed under the Python Software Foundation
+License Version 2.
+
+This plainCompleter module is designed for use in Regina's GUI, which uses
+Python subinterpreters.  The readline module does not play well with
+subinterpreters (due to the way it interacts with the GIL), and in some
+settings this results in a completely reproducible deadlock.  Such settings
+include openSUSE Leap 15.2, and macOS 11.0 using the Python3 that is shipped
+with Xcode.
+
+This plainCompleter module still offers a Completer class (which is all
+that the GUI needs), but it does not offer full readline functionality
+at the command line.  Crucially, importing this module will never attempt
+to import the readline module as a side-effect.
+
+Python's own rlcompleter documentation continues from here.
+
+The completer completes keywords, built-ins and globals in a selectable
+namespace (which defaults to __main__); when completing NAME.NAME..., it
+evaluates (!) the expression up to the last dot and completes its attributes.
+
+It's very cool to do "import sys" type "sys.", hit the completion key (twice),
+and see the list of names defined by the sys module!
+
+Tip: to use the tab key as the completion key, call
+
+    readline.parse_and_bind("tab: complete")
+
+Notes:
+
+- Exceptions raised by the completer function are *ignored* (and generally cause
+  the completion to fail).  This is a feature -- since readline sets the tty
+  device in raw (or cbreak) mode, printing a traceback wouldn't work well
+  without some complicated hoopla to save, reset and restore the tty state.
+
+- The evaluation of the NAME.NAME... form may cause arbitrary application
+  defined code to be executed if an object with a __getattr__ hook is found.
+  Since it is the responsibility of the application (or the user) to enable this
+  feature, I consider this an acceptable risk.  More complicated expressions
+  (e.g. function calls or indexing operations) are *not* evaluated.
+
+- When the original stdin is not a tty device, GNU readline is never
+  used, and this module (and the readline module) are silently inactive.
+
+"""
+
+import atexit
+import __main__
+
+# The original rlcompleter simply imports the builtins module.
+# However, we need to maintain compatibility with python 2 also.
+try:
+    import builtins
+except:
+    import __builtin__ as builtins
+
+__all__ = ["Completer"]
+
+class Completer:
+    def __init__(self, namespace = None):
+        """Create a new completer for the command line.
+
+        Completer([namespace]) -> completer instance.
+
+        If unspecified, the default namespace where completions are performed
+        is __main__ (technically, __main__.__dict__). Namespaces should be
+        given as dictionaries.
+
+        Completer instances should be used as the completion mechanism of
+        readline via the set_completer() call:
+
+        readline.set_completer(Completer(my_namespace).complete)
+        """
+
+        if namespace and not isinstance(namespace, dict):
+            raise TypeError('namespace must be a dictionary')
+
+        # Don't bind to namespace quite yet, but flag whether the user wants a
+        # specific namespace or to use __main__.__dict__. This will allow us
+        # to bind to __main__.__dict__ at completion time, not now.
+        if namespace is None:
+            self.use_main_ns = 1
+        else:
+            self.use_main_ns = 0
+            self.namespace = namespace
+
+    def complete(self, text, state):
+        """Return the next possible completion for 'text'.
+
+        This is called successively with state == 0, 1, 2, ... until it
+        returns None.  The completion should begin with 'text'.
+
+        """
+        if self.use_main_ns:
+            self.namespace = __main__.__dict__
+
+        if not text.strip():
+            if state == 0:
+                if _readline_available:
+                    readline.insert_text('\t')
+                    readline.redisplay()
+                    return ''
+                else:
+                    return '\t'
+            else:
+                return None
+
+        if state == 0:
+            if "." in text:
+                self.matches = self.attr_matches(text)
+            else:
+                self.matches = self.global_matches(text)
+        try:
+            return self.matches[state]
+        except IndexError:
+            return None
+
+    def _callable_postfix(self, val, word):
+        if callable(val):
+            word = word + "("
+        return word
+
+    def global_matches(self, text):
+        """Compute matches when text is a simple name.
+
+        Return a list of all keywords, built-in functions and names currently
+        defined in self.namespace that match.
+
+        """
+        import keyword
+        matches = []
+        seen = {"__builtins__"}
+        n = len(text)
+        for word in keyword.kwlist:
+            if word[:n] == text:
+                seen.add(word)
+                if word in {'finally', 'try'}:
+                    word = word + ':'
+                elif word not in {'False', 'None', 'True',
+                                  'break', 'continue', 'pass',
+                                  'else'}:
+                    word = word + ' '
+                matches.append(word)
+        for nspace in [self.namespace, builtins.__dict__]:
+            for word, val in nspace.items():
+                if word[:n] == text and word not in seen:
+                    seen.add(word)
+                    matches.append(self._callable_postfix(val, word))
+        return matches
+
+    def attr_matches(self, text):
+        """Compute matches when text contains a dot.
+
+        Assuming the text is of the form NAME.NAME....[NAME], and is
+        evaluable in self.namespace, it will be evaluated and its attributes
+        (as revealed by dir()) are used as possible completions.  (For class
+        instances, class members are also considered.)
+
+        WARNING: this can still invoke arbitrary C code, if an object
+        with a __getattr__ hook is evaluated.
+
+        """
+        import re
+        m = re.match(r"(\w+(\.\w+)*)\.(\w*)", text)
+        if not m:
+            return []
+        expr, attr = m.group(1, 3)
+        try:
+            thisobject = eval(expr, self.namespace)
+        except Exception:
+            return []
+
+        # get the content of the object, except __builtins__
+        words = set(dir(thisobject))
+        words.discard("__builtins__")
+
+        if hasattr(thisobject, '__class__'):
+            words.add('__class__')
+            words.update(get_class_members(thisobject.__class__))
+        matches = []
+        n = len(attr)
+        if attr == '':
+            noprefix = '_'
+        elif attr == '_':
+            noprefix = '__'
+        else:
+            noprefix = None
+        while True:
+            for word in words:
+                if (word[:n] == attr and
+                    not (noprefix and word[:n+1] == noprefix)):
+                    match = "%s.%s" % (expr, word)
+                    try:
+                        val = getattr(thisobject, word)
+                    except Exception:
+                        pass  # Include even if attribute not set
+                    else:
+                        match = self._callable_postfix(val, match)
+                    matches.append(match)
+            if matches or not noprefix:
+                break
+            if noprefix == '_':
+                noprefix = '__'
+            else:
+                noprefix = None
+        matches.sort()
+        return matches
+
+def get_class_members(klass):
+    ret = dir(klass)
+    if hasattr(klass,'__bases__'):
+        for base in klass.__bases__:
+            ret = ret + get_class_members(base)
+    return ret
+
+# Regina's edits are here.
+# Instead of trying to import the readline module, we just ignore it
+# and treat this module as a standalone completion tool.
+_readline_available = False

regina/pyCensus/__init__.py

@@ -0,0 +1,14 @@
+"""
+Dummy module to obtain path for census files from python.
+
+The TokyoCabinet database files .tdb are for versin version 1.0:910 and in
+little endian encoding suitable. Note that sageRegina is compiling its own
+version of TokyoCabinet so the files we supply should work on all operating
+systems and little endian platforms. 
+
+The .tdb files will be incompatible with the TokyoCabinet version shipped
+with Debian/Ubuntu because of a stupid bug: on these systems, TokyoCabinet
+is always using non-native (!) endianess (since --enable-swap was
+accidentally supplied to configure).
+
+"""

regina/sageRegina/__init__.py

@@ -0,0 +1,2 @@
+from .version import *
+from .test import *

regina/sageRegina/config.py

@@ -0,0 +1,9 @@
+tokyocabinet_uri  = 'https://dbmx.net/tokyocabinet/tokyocabinet-1.4.48.tar.gz'
+tokyocabinet_dir  = 'tokyocabinet-1.4.48'
+
+libxml_uri        = 'http://xmlsoft.org/sources/libxml2-2.9.3.tar.gz'
+libxml_dir        = 'libxml2-2.9.3'
+
+regina_hash      = '219d658e5e51cc003807fc8'  # regina-7.4.1
+regina_uri       = 'https://github.com/regina-normal/regina.git'
+regina_dir       = 'regina_%s' % regina_hash

regina/sageRegina/test.py

@@ -0,0 +1,131 @@
+from __future__ import print_function
+
+#__all__ = ['runTests']
+
+from .. import __dict__ as reginaDict
+from . version import version
+
+import sys
+import os
+import re
+import glob
+import difflib
+import traceback
+from io import StringIO
+
+base_path = os.path.split(__file__)[0]
+testsuite_path = os.path.join(base_path, 'testsuite')
+
+def runSource(source):
+
+    original_stdout = sys.stdout
+    original_displayhook = sys.displayhook
+    original_argv = sys.argv
+
+    fakeout = StringIO()
+    
+    sys.stdout = fakeout
+    sys.displayhook = sys.__displayhook__
+    sys.argv = ['regina', testsuite_path]
+
+    try:
+        globs = reginaDict.copy()
+        # this is regina.open which would otherwise clobber the
+        # builtin open expected by the tests
+        del globs['open']
+
+        class ReginaWrapper:
+            pass
+        reginaWrapper = ReginaWrapper()
+        reginaWrapper.__dict__ = reginaDict.copy()
+        globs['regina'] = reginaWrapper
+
+        exception_info = None
+        try:
+            exec(source, globs)
+        except:
+            exception_info = sys.exc_info()
+
+    finally:
+        sys.stdout = original_stdout
+        sys.displayhook = original_displayhook
+        sys.argv = original_argv
+
+    return fakeout.getvalue(), exception_info
+
+def runFile(path):
+    return runSource(open(path).read())
+
+def findTests():
+    search_path = os.path.join(testsuite_path, '*.test')
+    return [
+        (os.path.splitext(os.path.basename(path))[0], path)
+        for path in glob.glob(search_path)]
+
+def runTest(testName, testFile):
+    failed = ""
+
+    output, exception_info = runFile(testFile)
+
+    baseline = open(testFile.replace('.test', '.out')).read()
+
+    if testName == 'docstrings':
+        output = re.subn(r'(\s*)__pybind11_module_local_([a-zA-Z0-9_-]+) = <capsule.*\.\.\.',
+                         r'\1__pybind11_module_local__ = ...', output)[0]
+        output = re.subn(r'(\s*)Methods( inherited from pybind11_object:)',
+                         r'\1Static methods\2', output)[0]
+        output = re.subn(r'__new__\(\*args, \*\*kwargs\) class method of pybind11_builtins.pybind11_object',
+                         r'__new__(*args, **kwargs) from pybind11_builtins.pybind11_type',
+                         output)[0]
+
+    # For Python 3.12, there are trailing whitespace issues, so we
+    # normalize.
+    baseline = [line.strip() for line in baseline.split('\n')]
+    output = [line.strip() for line in output.split('\n')]
+    if output != baseline:
+        failed += "Difference between baseline and output:\n"
+        failed += '\n'.join(
+            difflib.context_diff(
+                baseline,
+                output,
+                fromfile = os.path.basename(testFile),
+                tofile = 'OUTPUT'))
+
+    if exception_info:
+        exception_type, exception, traceback_object = (
+            exception_info)
+        failed += "Raised exception: %s\n" % exception_type
+        failed += "Exception detail: %s\n" % exception
+        failed += "Trace:\n %s\n" % traceback.format_tb(traceback_object)
+
+    return failed
+
+def runTests():
+    print("Testing Regina " + version)
+    failedTests = []
+    
+    for testName, testFile in findTests():
+        if sys.version_info >= (3, 14) and testName == 'docstrings':
+            continue
+        
+        print("Running test %s:" % (testName + (20 - len(testName)) * " "),
+              end = ' ')
+        sys.stdout.flush()
+
+        failureOutput = runTest(testName, testFile)
+
+        if failureOutput:
+            failedTests.append(testName)
+            print("FAILED!!!")
+            print(failureOutput)
+        else:
+            print("ok")
+    
+    if failedTests:
+        print("The following %d test(s) failed: %s" % (
+                len(failedTests), ', '.join(failedTests)))
+    else:
+        print("All tests passed for Regina " + version)
+
+    return not failedTests
+

regina/sageRegina/testsuite/CMakeLists.txt

@@ -0,0 +1,64 @@
+
+CONFIGURE_FILE(
+  testall.in
+  "${PROJECT_BINARY_DIR}/python/testsuite/testall"
+  @ONLY
+)
+CONFIGURE_FILE(
+  testbasic.in
+  "${PROJECT_BINARY_DIR}/python/testsuite/testbasic"
+  @ONLY
+)
+CONFIGURE_FILE(
+  testsub.in
+  "${PROJECT_BINARY_DIR}/python/testsuite/testsub"
+  @ONLY
+)
+CONFIGURE_FILE(
+  testcallback.in
+  "${PROJECT_BINARY_DIR}/python/testsuite/testcallback"
+  @ONLY
+)
+CONFIGURE_FILE(
+  runbasic.in
+  "${PROJECT_BINARY_DIR}/python/testsuite/runbasic"
+  @ONLY
+)
+
+# A very basic interpreter (and related code) to use for testing:
+INCLUDE_DIRECTORIES(${Python_INCLUDE_DIRS} ${ENGINE_INCLUDES} "${PROJECT_BINARY_DIR}/engine")
+ADD_LINK_OPTIONS(${Python_LINK_OPTIONS})
+add_executable(basic
+  basic.cpp
+  ../gui/pythoninterpreter.cpp
+  ../gui/pythonoutputstream.cpp)
+target_link_libraries(basic ${ENGINE_LIBRARY} ${Python_LIBRARIES})
+add_executable(basic_alltypes
+  basic_alltypes.cpp
+  ../gui/pythoninterpreter.cpp
+  ../gui/pythonoutputstream.cpp)
+target_link_libraries(basic_alltypes ${ENGINE_LIBRARY} ${Python_LIBRARIES})
+add_executable(basic_sub
+  basic_sub.cpp
+  ../gui/pythoninterpreter.cpp
+  ../gui/pythonoutputstream.cpp)
+target_link_libraries(basic_sub ${ENGINE_LIBRARY} ${Python_LIBRARIES})
+add_executable(basic_callback
+  basic_callback.cpp
+  ../gui/pythoninterpreter.cpp
+  ../gui/pythonoutputstream.cpp)
+target_link_libraries(basic_callback ${ENGINE_LIBRARY} ${Python_LIBRARIES})
+
+IF (WIN32)
+  ADD_TEST(python-test bash testall)
+  ADD_TEST(python-basic bash testbasic)
+  ADD_TEST(python-sub bash testsub)
+  ADD_TEST(python-callback bash testcallback)
+  # We do not need to add the engine DLL location to the path, since
+  # regina-python (used in testall) and testbasic (directly) do this for us.
+ELSE (WIN32)
+  ADD_TEST(python-test ./testall)
+  ADD_TEST(python-basic ./testbasic)
+  ADD_TEST(python-sub ./testsub)
+  ADD_TEST(python-callback ./testcallback)
+ENDIF (WIN32)

regina/sageRegina/testsuite/O2_1.rga

@@ -0,0 +1,15 @@
+<?xml version="1.0"?>
+<reginadata engine="4.5">
+<packet label="Container"
+	type="Container" typeid="1"
+	parent="">
+<packet label="O2₁"
+	type="Triangulation" typeid="3"
+	parent="Container">
+  <tetrahedra ntet="2">
+    <tet desc=""> 1 180 1 30 1 39 1 114 </tet>
+    <tet desc=""> 0 180 0 141 0 39 0 75 </tet>
+  </tetrahedra>
+</packet> <!-- O2₁ (Triangulation) -->
+</packet> <!-- Container (Container) -->
+</reginadata>