regina 7.3.1__cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

regina/sageRegina/testsuite/alltypes.test

@@ -0,0 +1,88 @@
+# Regina - A Normal Surface Theory Calculator
+# Python Test Suite Component
+#
+# Copyright (c) 2015-2023, Ben Burton
+# For further details contact Ben Burton (bab@debian.org).
+#
+# Prints basic properties of all wrapped objects and types.
+#
+# This file is a single component of Regina's python test suite.  To run
+# the python test suite, move to the main python directory in the source
+# tree and run "make check".
+#
+# 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, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
+# MA 02110-1301, USA.
+
+import re
+
+regex = re.compile("^<class 'regina\\.engine\\.(.+)'>$")
+
+def classInfo(name, object):
+    m = regex.match(str(object))
+    if not m:
+        print(name, ': ERROR - could not determine real class name.')
+    else:
+        realName = m.group(1)
+        if realName == name:
+            if name == 'Bitmask256' or name == 'Qitmask256':
+                # These classes are only present on 64-bit machines.
+                # Omit them here so that this test generates the same output
+                # across all platforms.
+                return
+            print(name, ': class')
+            try:
+                print('Equality type :', object.equalityType)
+            except:
+                # We allow this for exception types.
+                if object.__base__ is RuntimeError:
+                    print('Exception type')
+                else:
+                    print('ERROR: No equality type')
+        else:
+            print(name, ': alias -> ', realName)
+    print()
+
+def enumInfo(name, object):
+    # print name, ': enum'
+    pass
+
+def functionInfo(name, object):
+    # print name, ': function'
+    pass
+
+def objectInfo(name, object):
+    # print name, ': object'
+    pass
+
+keys = sorted(regina.__dict__)
+
+for i in keys:
+    object = regina.__dict__[i]
+    if isinstance(object, type):
+        try:
+            tmp = object.__members__ # Exists for enums, not classes
+            enumInfo(i, object)
+        except AttributeError:
+            classInfo(i, object)
+    elif 'builtin_function_or_method' in str(object.__class__):
+        functionInfo(i, object)
+    else:
+        objectInfo(i, object)

regina/sageRegina/testsuite/angles.out

@@ -0,0 +1,102 @@
+-------------------------------
+Empty triangulation
+Vertex angle structures
+-------------------------------
+
+1 vertex angle structure (no restrictions):
+
+
+
+-------------------------------
+Empty triangulation
+Taut angle structures
+-------------------------------
+
+1 vertex angle structure (taut only):
+
+
+
+-------------------------------
+Figure eight knot complement
+Vertex angle structures
+-------------------------------
+
+5 vertex angle structures (no restrictions):
+1 0 0 ; 1 0 0
+1 0 0 ; 0 1/2 1/2
+0 1/2 1/2 ; 1 0 0
+0 1 0 ; 0 0 1
+0 0 1 ; 0 1 0
+
+
+-------------------------------
+Figure eight knot complement
+Taut angle structures
+-------------------------------
+
+3 vertex angle structures (taut only):
+1 0 0 ; 1 0 0
+0 1 0 ; 0 0 1
+0 0 1 ; 0 1 0
+
+
+-------------------------------
+Whitehead link complement
+Vertex angle structures
+-------------------------------
+
+18 vertex angle structures (no restrictions):
+1/2 1/2 0 ; 1/2 1/2 0 ; 1 0 0 ; 0 0 1
+1/2 1/2 0 ; 1/2 1/2 0 ; 0 0 1 ; 1 0 0
+1/2 1/2 0 ; 1 0 0 ; 1/2 1/2 0 ; 0 0 1
+1/2 1/2 0 ; 0 0 1 ; 1/2 1/2 0 ; 1 0 0
+1 0 0 ; 1/2 1/2 0 ; 0 0 1 ; 1/2 1/2 0
+1 0 0 ; 1 0 0 ; 0 1 0 ; 0 1 0
+1 0 0 ; 1 0 0 ; 0 0 1 ; 0 0 1
+1 0 0 ; 0 1 0 ; 1 0 0 ; 0 1 0
+1 0 0 ; 0 0 1 ; 1/2 1/2 0 ; 1/2 1/2 0
+1 0 0 ; 0 0 1 ; 1 0 0 ; 0 0 1
+1 0 0 ; 0 0 1 ; 0 0 1 ; 1 0 0
+0 1 0 ; 1 0 0 ; 0 1 0 ; 1 0 0
+0 1 0 ; 0 1 0 ; 1 0 0 ; 1 0 0
+0 0 1 ; 1/2 1/2 0 ; 1 0 0 ; 1/2 1/2 0
+0 0 1 ; 1 0 0 ; 1/2 1/2 0 ; 1/2 1/2 0
+0 0 1 ; 1 0 0 ; 1 0 0 ; 0 0 1
+0 0 1 ; 1 0 0 ; 0 0 1 ; 1 0 0
+0 0 1 ; 0 0 1 ; 1 0 0 ; 1 0 0
+
+
+-------------------------------
+Whitehead link complement
+Taut angle structures
+-------------------------------
+
+10 vertex angle structures (taut only):
+1 0 0 ; 1 0 0 ; 0 1 0 ; 0 1 0
+1 0 0 ; 1 0 0 ; 0 0 1 ; 0 0 1
+1 0 0 ; 0 1 0 ; 1 0 0 ; 0 1 0
+1 0 0 ; 0 0 1 ; 1 0 0 ; 0 0 1
+1 0 0 ; 0 0 1 ; 0 0 1 ; 1 0 0
+0 1 0 ; 1 0 0 ; 0 1 0 ; 1 0 0
+0 1 0 ; 0 1 0 ; 1 0 0 ; 1 0 0
+0 0 1 ; 1 0 0 ; 1 0 0 ; 0 0 1
+0 0 1 ; 1 0 0 ; 0 0 1 ; 1 0 0
+0 0 1 ; 0 0 1 ; 1 0 0 ; 1 0 0
+
+
+-------------------------------
+Poincare homology sphere
+Vertex angle structures
+-------------------------------
+
+0 vertex angle structures (no restrictions):
+
+
+-------------------------------
+Poincare homology sphere
+Taut angle structures
+-------------------------------
+
+0 vertex angle structures (taut only):
+
+

regina/sageRegina/testsuite/angles.test

@@ -0,0 +1,72 @@
+# Regina - A Normal Surface Theory Calculator
+# Python Test Suite Component
+#
+# Copyright (c) 2007-2023, Ben Burton
+# For further details contact Ben Burton (bab@debian.org).
+#
+# Provides various tests for angle structure enumeration.
+#
+# This file is a single component of Regina's python test suite.  To run
+# the python test suite, move to the main python directory in the source
+# tree and run "make check".
+#
+# 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, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
+# MA 02110-1301, USA.
+
+def dumpAngles(name, tri, triName, tautOnly = False):
+	try:
+		slist = regina.AngleStructures(tri, tautOnly)
+	except:
+		print("-------------------------------")
+		print(name)
+		print('ENUMERATION FAILED')
+		print("-------------------------------")
+		print()
+		return
+	
+	print("-------------------------------")
+	print(triName)
+	print(name)
+	print("-------------------------------")
+	print()
+	
+	# Dump the angle structures in sort order, since we don't really mind if
+	# the ordering changes between releases.
+	structures = slist.detail().split('\n')
+	structures.sort()
+	# Let the text headers appear up top.
+	structures.reverse()
+	for s in structures:
+		print(s)
+	
+	# Nothing else to say.
+	print()
+
+def angleStats(tri, triName):
+	dumpAngles('Vertex angle structures', tri, triName, False)
+	dumpAngles('Taut angle structures', tri, triName, True)
+
+t = regina.Triangulation3()
+angleStats(t, 'Empty triangulation')
+
+angleStats(regina.Example3.figureEight(), 'Figure eight knot complement')
+angleStats(regina.Example3.whiteheadLink(), 'Whitehead link complement')
+angleStats(regina.Example3.poincare(), 'Poincare homology sphere')

regina/sageRegina/testsuite/basic.cpp

@@ -0,0 +1,229 @@
+
+/**************************************************************************
+ *                                                                        *
+ *  Regina - A Normal Surface Theory Calculator                           *
+ *  Python Interface                                                      *
+ *                                                                        *
+ *  Copyright (c) 1999-2023, 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, write to the Free            *
+ *  Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,       *
+ *  MA 02110-1301, USA.                                                   *
+ *                                                                        *
+ **************************************************************************/
+
+#include "../gui/pythoninterpreter.h"
+#include "../gui/pythonoutputstream.h"
+#include <fstream>
+#include <iostream>
+#include <condition_variable>
+#include <thread>
+
+/**
+ * This is a very basic Python interpreter, designed to test scenarios
+ * where Python is embedded in a C++ program.  It processes input commands
+ * one line at a time (so even if a script is passed via the command line,
+ * it behaves as though the input were interactive).
+ *
+ * If -t <seconds> is passed, the interpreter runs under a strict time limit:
+ * it will exit with non-zero error status if the given time limit is exceeded.
+ * This is so that deadlock scenarios can be detected and reported effectively.
+ *
+ * The main reason for having this basic interpreter is so we can more easily
+ * test for problems that might occur in the Qt GUI (e.g., problems related to
+ * multithreading, or subinterpreters, or the global interpreter lock).
+ *
+ * This interpreter is designed to be run directly out of the source tree.
+ * It does not set LD_LIBRARY_PATH, PYTHONHOME or PYTHONPATH at all; it is
+ * up to whoever calls this interpreter to set these paths appropriately.
+ */
+
+long timeout = 0; // measured in seconds
+bool mainThread = true;
+
+std::condition_variable cond; // used with timeout mechanism
+bool finished = false;
+std::mutex mutex; // guards finished and cond
+
+class NativeOutputStream : public regina::python::PythonOutputStream {
+    private:
+        std::ostream& stream_;
+
+    public:
+        NativeOutputStream(std::ostream& stream) : stream_(stream) {}
+
+    protected:
+        virtual void processOutput(const std::string& data) override {
+            stream_ << data;
+            stream_.flush();
+        }
+};
+
+void usage(const char* progName, const std::string& error = std::string()) {
+    if (! error.empty())
+        std::cerr << error << "\n\n";
+
+    std::cerr << "Usage:\n";
+    std::cerr << "    " << progName << " [ -m ] [ -t <seconds> ] [ <commands> ]\n";
+    std::cerr << "    " << progName << " -v\n";
+    std::cerr << std::endl;
+    std::cerr << "    -m : Execute commands in a different thread\n";
+    std::cerr << "    -t : Timeout after the given number of seconds\n";
+    std::cerr << "    -v : Output the Python version being used\n";
+    std::cerr << std::endl;
+    std::cerr << "    <script> : Read commands line-by-line from the "
+        "given file (otherwise\n";
+    std::cerr << "               uses standard input)\n";
+    exit(1);
+}
+
+void watcher() {
+    std::unique_lock<std::mutex> lock(mutex);
+
+    // At this point, either finished is true, or else the main thread
+    // will not be able to notify the condition variable until *after*
+    // we wait (thus ensuring we will be properly woken up).
+
+    if (finished)
+        return;
+
+    if (cond.wait_for(lock, std::chrono::seconds(timeout)) ==
+            std::cv_status::timeout) {
+        std::cerr << "ERROR: Timed out after " << timeout  << "s." << std::endl;
+
+        // We assume the python code is deadlocked; we will not be able to
+        // clean up Python properly.
+        exit(3);
+    }
+}
+
+void run(regina::python::PythonInterpreter& py, std::istream& input) {
+    std::string line;
+    while (input) {
+        std::getline(input, line);
+        if (mainThread) {
+            py.executeLine(line);
+        } else {
+            std::thread([&]() {
+                py.executeLine(line);
+            }).join();
+        }
+    }
+}
+
+int main(int argc, char* argv[]) {
+    std::string input;
+
+    for (int i = 1; i < argc; ++i) {
+        if (*argv[i] == '-') {
+            if (! (argv[i][1] && ! argv[i][2]))
+                usage(argv[0], "Unknown option.");
+            switch (argv[i][1]) {
+                case 'v':
+                    if (argc == 2) {
+                        std::cout << PY_MAJOR_VERSION << '.'
+                            << PY_MINOR_VERSION << '.'
+                            << PY_MICRO_VERSION << std::endl;
+                        return 0;
+                    } else
+                        usage(argv[0],
+                            "Argument -v cannot be used with other options.");
+                case 'm':
+                    mainThread = false;
+                    break;
+                case 't':
+                    if (i == argc - 1)
+                        usage(argv[0], "Missing timeout argument.");
+                    ++i;
+                    {
+                        char* err = nullptr;
+                        timeout = strtol(argv[i], &err, 10);
+                        if (*err)
+                            usage(argv[0], "Timeout should be an integer.");
+                        else if (timeout <= 0)
+                            usage(argv[0],
+                                "Timeout should be strictly positive.");
+                    }
+                    break;
+                default:
+                    usage(argv[0], "Unknown option.");
+            }
+        } else {
+            if (i != argc - 1)
+                usage(argv[0], "The <commands> argument must come last.");
+            input = argv[i];
+        }
+    }
+
+    NativeOutputStream out(std::cout);
+    NativeOutputStream err(std::cerr);
+    // In the new python interpreter, do not adjust the Python path to reflect
+    // Regina's installation location, since this tool is designed to be
+    // run directly out of the source tree.
+    regina::python::PythonInterpreter py(out, err, false);
+    if (! py.importRegina(false)) {
+        std::cerr << "ERROR: Could not import regina" << std::endl;
+        exit(2);
+    }
+
+    py.executeLine("from regina import *");
+    std::string exec = argv[0];
+    py.executeLine("regina.GlobalDirs.deduceDirs('" + exec + "');");
+
+    if (input.empty()) {
+        if (timeout) {
+            std::thread w(watcher);
+            run(py, std::cin);
+            {
+                std::unique_lock<std::mutex> lock(mutex);
+                finished = true;
+            }
+            cond.notify_one();
+
+            w.join();
+        } else {
+            run(py, std::cin);
+        }
+    } else {
+        std::ifstream in(input);
+        if (! in) {
+            std::cerr << "ERROR: Could not open input file: " << input
+                << std::endl;
+            return 1;
+        }
+        if (timeout) {
+            std::thread w(watcher);
+            run(py, in);
+            {
+                std::unique_lock<std::mutex> lock(mutex);
+                finished = true;
+            }
+            cond.notify_one();
+
+            w.join();
+        } else {
+            run(py, in);
+        }
+    }
+
+    return 0;
+}
+

regina/sageRegina/testsuite/bool.out

@@ -0,0 +1,6 @@
+Non-null disc type
+Null disc type
+Non-null strand ref
+Null strand ref
+Non-null graph arc
+Null graph arc

regina/sageRegina/testsuite/bool.test

@@ -0,0 +1,64 @@
+# Regina - A Normal Surface Theory Calculator
+# Python Test Suite Component
+#
+# Copyright (c) 2007-2023, Ben Burton
+# For further details contact Ben Burton (bab@debian.org).
+#
+# Tests casts to booleans.
+#
+# This file is a single component of Regina's python test suite.  To run
+# the python test suite, move to the main python directory in the source
+# tree and run "make check".
+#
+# 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, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
+# MA 02110-1301, USA.
+
+if DiscType(0, 0):
+	print('Non-null disc type')
+else:
+	print('Null disc type')
+
+if DiscType():
+	print('Non-null disc type')
+else:
+	print('Null disc type')
+
+if ExampleLink.whitehead().component(0):
+	print('Non-null strand ref')
+else:
+	print('Null strand ref')
+
+if Link(1).component(0):
+	print('Non-null strand ref')
+else:
+	print('Null strand ref')
+
+g = ModelLinkGraph.fromPlantri('bcdd,aeec,abfd,acfa,bffb,ceed')
+if g.node(0).adj(0):
+	print('Non-null graph arc')
+else:
+	print('Null graph arc')
+
+if ModelLinkGraphArc():
+	print('Non-null graph arc')
+else:
+	print('Null graph arc')
+

regina/sageRegina/testsuite/bytes.out

@@ -0,0 +1,17 @@
+YXNkZg==
+True
+YQBkZg==
+True
+AAAAAAA=
+True
+AAAAAAAA
+True
+None
+
+None
+5
+YXMAZGY=
+YXMAZGY=
+3
+AAAA
+AAAA

regina/sageRegina/testsuite/bytes.test

@@ -0,0 +1,78 @@
+# Regina - A Normal Surface Theory Calculator
+# Python Test Suite Component
+#
+# Copyright (c) 2007-2023, Ben Burton
+# For further details contact Ben Burton (bab@debian.org).
+#
+# Tests code that works with raw byte sequences.
+#
+# This file is a single component of Regina's python test suite.  To run
+# the python test suite, move to the main python directory in the source
+# tree and run "make check".
+#
+# 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, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
+# MA 02110-1301, USA.
+
+b = b'asdf'
+s = regina.base64Encode(b)
+print(s)
+b2 = regina.base64Decode(s)
+print(b == b2)
+
+b = b'a\0df'
+s = regina.base64Encode(b)
+print(s)
+b2 = regina.base64Decode(s)
+print(b == b2)
+
+b = b'\0\0\0\0\0'
+s = regina.base64Encode(b)
+print(s)
+b2 = regina.base64Decode(s)
+print(b == b2)
+
+b = b'\0\0\0\0\0\0'
+s = regina.base64Encode(b)
+print(s)
+b2 = regina.base64Decode(s)
+print(b == b2)
+
+print(regina.base64Decode('!!')) # should be None
+
+print()
+
+########################################################################
+
+a = Attachment()
+print(a.data())
+
+b = b'as\0df'
+a = Attachment(b, 'bytes.dat')
+print(a.size())
+print(base64Encode(b))
+print(base64Encode(a.data()))
+
+b = b'\0\0\0'
+a.reset(b, 'null.dat')
+print(a.size())
+print(base64Encode(b))
+print(base64Encode(a.data()))
+