passagemath-gap-pkg-curlinterface 10.6.39__cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl

gap/pkg/curlinterface/gap/curl.gd

@@ -0,0 +1,169 @@
+#
+# curlInterface: Simple Web Access
+#
+#! @Chapter Overview
+#!
+#! CurlInterface allows a user to interact with http and https
+#! servers on the internet, using the 'curl' library.
+#! Pages can be downloaded from a URL, and http POST requests
+#! can be sent to the URL for processing.
+
+#! @Section Installing curlInterface
+#!
+#! curlInterface requires the 'curl' library, available from
+#! <URL>https://curl.haxx.se/</URL>. Instructions for building
+#! and installing curl can be found at
+#! <URL>https://curl.haxx.se/docs/install.html</URL>, however
+#! in most systems curl can be installed from your OS's package
+#! manager.
+#!
+#! @Subsection Linux
+#!
+#! <List>
+#! <Item>
+#! On Debian and Ubuntu, call: <C>apt-get install libcurl4-gnutls-dev</C></Item>
+#! <Item>
+#! On Redhat and derivatives, call: <C>yum install curl-devel</C></Item>
+#! </List>
+#!
+#! @Subsection Cygwin
+#!
+#! Install <C>libcurl-devel</C> from the cygwin package manager
+#!
+#! @Subsection macOS
+#!
+#! curl is installed by default on Macs, but libcurl may be required.
+#! <List>
+#! <Item>Homebrew: <C>brew install curl</C></Item>
+#! <Item>Fink: <C>fink install libcurl4</C></Item>
+#! <Item>MacPorts: <C>port install curl</C></Item>
+#! </List>
+
+#! @Section Functions
+#!
+#! curlInterface currently provides the following functions for interacting with
+#! URLs:
+
+#! @Arguments URL[, opts]
+#! @Returns
+#!   a record
+#! @Description
+#!   Downloads a URL from the internet.  <A>URL</A> should be a string
+#!   describing the address, and should start with either "http://" or
+#!   "https://".
+#!   For descriptions of the output and the additional argument <A>opts</A>, see
+#!   <Ref Func="CurlRequest"/>.
+#!
+#! @BeginExample
+#! gap> r := DownloadURL("www.gap-system.org");;
+#! gap> r.success;
+#! true
+#! gap> r.result{[1..50]};
+#! "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n\n<!DOCTYPE "
+#! @EndExample
+DeclareGlobalFunction("DownloadURL");
+
+#! @Arguments URL, str[, opts]
+#! @Returns
+#!   a record
+#! @Description
+#!   Sends an HTTP POST request to a URL on the internet. <A>URL</A> should be a
+#!   string describing the address, and should start with either "http://" or
+#!   "https://".  <A>str</A> should be the string which will be sent to the
+#!   server as a POST request.
+#!   For descriptions of the output and the additional argument <A>opts</A>, see
+#!   <Ref Func="CurlRequest"/>.
+#!
+#! @BeginExample
+#! gap> r := PostToURL("httpbun.com/post", "animal=tiger");;
+#! gap> r.success;
+#! true
+#! gap> r.result{[51..100]};
+#! "\"form\": {\n    \"animal\": \"tiger\"\n  }, \n  \"headers\":"
+#! @EndExample
+DeclareGlobalFunction("PostToURL");
+
+#! @Arguments URL[, opts]
+#! @Returns
+#!   a record
+#! @Description
+#!   Attempts to delete a file on the internet, by sending an HTTP DELETE
+#!   request to the given URL.  <A>URL</A> should be a string describing the
+#!   address to be deleted, and should start with either "http://" or
+#!   "https://".
+#!   For descriptions of the output and the additional argument <A>opts</A>, see
+#!   <Ref Func="CurlRequest"/>.
+#!
+#! @BeginExample
+#! gap> r := DeleteURL("www.google.com");;
+#! gap> r.success;
+#! true
+#! gap> r.result{[1471..1540]};
+#! "<p>The request method <code>DELETE</code> is inappropriate for the URL"
+#! @EndExample
+DeclareGlobalFunction("DeleteURL");
+
+#! @Arguments URL, type, out_string[, opts]
+#! @Returns
+#!   a record
+#! @Description
+#!   Sends an HTTP request of type <A>type</A> to a URL on the internet.
+#!   <A>URL</A>, <A>type</A>, and <A>out_string</A> should all be strings:
+#!   <A>URL</A> is the URL of the server (which should start with "http://" or
+#!   "https://"), <A>type</A> is the type of HTTP request (e.g. "GET"), and
+#!   <A>out_string</A> is the message, if any, to send to the server (in
+#!   requests such as GET this will be ignored).
+#!
+#!   An optional fourth argument <A>opts</A> may be included, which should be a
+#!   record specifying additional options for the request.  The following
+#!   options are supported:
+#!     * <C>verifyCert</C>: a boolean describing whether to verify HTTPS
+#!       certificates
+#!       (corresponds to the curl options <C>CURLOPT_SSL_VERIFYPEER</C>
+#!       and <C>CURLOPT_SSL_VERIFYHOST</C>,
+#!       the default is <K>true</K> for both);
+#!     * <C>verbose</C>: a boolean describing whether to print extra information
+#!       to the screen
+#!       (corresponds to the curl option <C>CURLOPT_VERBOSE</C>,
+#!       the default is <K>false</K>);
+#!     * <C>followRedirect</C>: a boolean describing whether to follow
+#!       redirection to another URL
+#!       (corresponds to the curl option <C>CURLOPT_FOLLOWLOCATION</C>,
+#!       the default is <K>true</K>);
+#!     * <C>failOnError</C>: a boolean describing whether to regard
+#!       404 (and other 4xx) status codes as error
+#!       (corresponds to the curl option <C>CURLOPT_FAILONERROR</C>,
+#!       the default is <K>false</K>).
+#!     * <C>maxTime</C>: Maximum time in seconds that you allow each transfer
+#!       to take. 0 means no limitation. (default <K>0</K>).
+#!
+#!   As output, this function returns a record containing some of the following
+#!   components, which describe the outcome of the request:
+#!     * <C>success</C>: a boolean describing whether the request was
+#!       successfully received by the server;
+#!     * <C>result</C>: body of the information sent by the server (only if
+#!       <C>success = true</C>);
+#!     * <C>error</C>: human-readable string saying what went wrong (only if
+#!       <C>success = false</C>).
+#!
+#!   Most of the standard HTTP request types should work, but currently only
+#!   body information is returned.  To see headers, consider using the
+#!   <C>verbose</C> option.  For convenience, dedicated functions exist for the
+#!   following request types:
+#!     * <Ref Func="DownloadURL"/> for GET requests;
+#!     * <Ref Func="PostToURL"/> for POST requests;
+#!     * <Ref Func="DeleteURL"/> for DELETE requests.
+#!
+#! @BeginExample
+#! gap> r := CurlRequest("https://www.google.com",
+#! >                     "HEAD",
+#! >                     "",
+#! >                     rec(verifyCert := false));
+#! rec( result := "", success := true )
+#! gap> r := CurlRequest("httpbun.com/post", "POST", "animal=tiger");;
+#! gap> r.success;
+#! true
+#! gap> r.result{[51..100]};
+#! "\"form\": {\n    \"animal\": \"tiger\"\n  }, \n  \"headers\":"
+#! @EndExample
+DeclareGlobalFunction("CurlRequest");

gap/pkg/curlinterface/gap/curl.gi

@@ -0,0 +1,67 @@
+#
+# curlInterface: Simple Web Access
+#
+# Implementations
+#
+InstallGlobalFunction("CurlRequest",
+function(URL, type, out_string, opts...)
+    local r, rnam;
+
+    # Get options
+    r := rec(verifyCert := true, verbose := false, followRedirect := true,
+             failOnError:= false, maxTime := 0);
+    if Length(opts) = 1 then
+        if not IsRecord(opts[1]) then
+            ErrorNoReturn("CurlRequest: <opts> must be a record");
+        fi;
+        for rnam in RecNames(opts[1]) do
+            r.(rnam) := opts[1].(rnam);
+        od;
+    elif Length(opts) > 1 then
+        ErrorNoReturn("CurlRequest: usage: requires 3 or 4 arguments, but ",
+                      Length(opts) + 3, " were given");
+    fi;
+
+    # Check input
+    if not IsString(URL) then
+        ErrorNoReturn("CurlRequest: <URL> must be a string");
+    elif not IsString(type) then
+        ErrorNoReturn("CurlRequest: <type> must be a string");
+    elif not IsString(out_string) then
+        ErrorNoReturn("CurlRequest: <out_string> must be a string");
+    fi;
+    for rnam in ["verifyCert", "verbose", "followRedirect", "failOnError"] do
+        if r.(rnam) <> true and r.(rnam) <> false then
+            ErrorNoReturn("CurlRequest: <opts>.", rnam,
+                          " must be true or false");
+        fi;
+    od;
+    for rnam in ["maxTime"] do
+        if r.(rnam) <> 0 and not IsPosInt(r.(rnam)) then
+            ErrorNoReturn("CurlRequest: <opts>.", rnam,
+                          " must be a non-negative integer");
+        fi;
+    od;
+
+    return CURL_REQUEST(URL, type, out_string,
+                        r.verifyCert,
+                        r.verbose,
+                        r.followRedirect,
+                        r.failOnError,
+                        r.maxTime);
+end);
+
+InstallGlobalFunction("DownloadURL",
+function(URL, opts...)
+    return CallFuncList(CurlRequest, Concatenation([URL, "GET", ""], opts));
+end);
+
+InstallGlobalFunction("PostToURL",
+function(URL, str, opts...)
+    return CallFuncList(CurlRequest, Concatenation([URL, "POST", str], opts));
+end);
+
+InstallGlobalFunction("DeleteURL",
+function(URL, opts...)
+    return CallFuncList(CurlRequest, Concatenation([URL, "DELETE", ""], opts));
+end);

gap/pkg/curlinterface/init.g

@@ -0,0 +1,15 @@
+#
+# curlInterface: Simple Web Access
+#
+# Reading the declaration part of the package.
+#
+
+if not LoadKernelExtension("curlInterface", "curl") then
+  Error("failed to load the curlInterface package kernel extension");
+fi;
+
+# work around a bug in some PackageManager versions, see
+# <https://github.com/gap-packages/PackageManager/pull/100>.
+Unbind(DownloadURL);
+
+ReadPackage( "curlInterface", "gap/curl.gd");

gap/pkg/curlinterface/makedoc.g

@@ -0,0 +1,10 @@
+#
+# curlInterface: Simple Web Access
+#
+# This file is a script which compiles the package manual.
+#
+if fail = LoadPackage("AutoDoc", "2016.02.16") then
+    Error("AutoDoc version 2016.02.16 or newer is required.");
+fi;
+
+AutoDoc( rec( scaffold := true, autodoc := true ) );

gap/pkg/curlinterface/read.g

@@ -0,0 +1,6 @@
+#
+# curlInterface: Simple Web Access
+#
+# Reading the implementation part of the package.
+#
+ReadPackage( "curlInterface", "gap/curl.gi");

gap/pkg/curlinterface/tst/basic.tst

@@ -0,0 +1,198 @@
+gap> LoadPackage("curlInterface", false);
+true
+
+# Check HTTP
+gap> r := DownloadURL("http://www.google.com");;
+gap> SortedList(RecNames(r));
+[ "result", "success" ]
+gap> r.success;
+true
+gap> PositionSublist(r.result, "google") <> fail;
+true
+gap> PositionSublist("google", r.result) <> fail;
+false
+
+# Sanity check the result without actually printing it
+gap>  PositionSublist(r.result, "google") <> fail;
+true
+gap> r.result[1];
+'<'
+
+# Check HTTPS
+gap> r := DownloadURL("https://www.google.com");;
+gap> SortedList(RecNames(r));
+[ "result", "success" ]
+gap> r.success;
+true
+gap> PositionSublist(r.result, "google") <> fail;
+true
+gap> PositionSublist("google", r.result) <> fail;
+false
+
+# Sanity check the result without actually printing it
+gap>  PositionSublist(r.result, "google") <> fail;
+true
+gap> r.result[1];
+'<'
+
+# Check FTP
+# Removed since we do not officially support FTP and it may fail in Docker
+#gap> r := DownloadURL("ftp://fra36-speedtest-1.tele2.net/1KB.zip");;
+#gap> SortedList(RecNames(r));
+#[ "result", "success" ]
+#gap> r.success;
+#true
+#gap> r.result = ListWithIdenticalEntries(1024, '\000');
+#true
+
+# Check bad URL
+gap> r := DownloadURL("https://www.google.cheesebadger");;
+gap> SortedList(RecNames(r));
+[ "error", "success" ]
+gap> r.success;
+false
+gap> PositionSublist(r.error, "Could not resolve host") <> fail;
+true
+
+# Check another bad URL
+gap> r := DownloadURL("https://www.gap-system.org/Packages/curlInterface.x");;
+gap> r.success;
+true
+gap> PositionSublist(r.result, "URL was not found") <> fail;
+true
+gap> r := DownloadURL("https://www.gap-system.org/Packages/curlInterface.x",
+>           rec(failOnError:= true));;
+gap> r.success;
+false
+gap> PositionSublist(r.error, "404") <> fail;
+true
+
+# Check successful POST requests
+gap> r := PostToURL("httpbun.com/post", "field1=true&field2=17");;
+gap> SortedList(RecNames(r));
+[ "result", "success" ]
+gap> r.success;
+true
+gap> PositionSublist(r.result, "\"field1\": \"true\"") <> fail;
+true
+gap> PositionSublist(r.result, "\"field2\": \"17\"") <> fail;  
+true
+gap> PositionSublist(r.result, "field3") <> fail;
+false
+
+# Check POST on a string with null characters
+gap> r := PostToURL("httpbun.com/post", "field1=my\000first\000field");;
+gap> SortedList(RecNames(r));
+[ "result", "success" ]
+gap> r.success;
+true
+gap> PositionSublist(r.result, "my\\u0000first\\u0000field") <> fail;
+true
+gap> PositionSublist(r.result, "field3") <> fail;
+false
+
+# Check POST method not allowed (405)
+gap> r := PostToURL("www.google.com", "myfield=42");;
+gap> SortedList(RecNames(r));
+[ "result", "success" ]
+gap> r.success;
+true
+gap> PositionSublist(r.result, "myfield") <> fail;
+false
+gap> PositionSublist(r.result, "405") <> fail;
+true
+
+# Check bad URL with POST
+gap> r := PostToURL("https://www.google.cheesebadger", "hello");;
+gap> SortedList(RecNames(r));
+[ "error", "success" ]
+gap> r.success;
+false
+gap> PositionSublist(r.error, "Could not resolve host") <> fail;
+true
+
+# Check not IsStringRep (url)
+gap> url := List("https://www.google.com", letter -> letter);;
+gap> IsStringRep(url);
+false
+gap> r := DownloadURL(url);;
+gap> SortedList(RecNames(r));
+[ "result", "success" ]
+gap> r.success;
+true
+gap> PositionSublist(r.result, "google") <> fail;
+true
+
+# Check not IsStringRep (post_string)
+gap> post_string := List("animal=tiger&material=cotton", letter -> letter);;
+gap> IsStringRep(post_string);
+false
+gap> r := PostToURL("httpbun.com/post", post_string, rec(verifyCert := true));;
+gap> r.success;
+true
+gap> PositionSublist(r.result, "\"animal\": \"tiger\"") <> fail;
+true
+gap> PositionSublist(r.result, "\"material\": \"cotton\"") <> fail;
+true
+gap> PositionSublist(r.result, "lion") <> fail;
+false
+
+# Check not IsStringRep (request type)
+gap> r := CurlRequest("www.google.com", ['G', 'E', 'T'] , "");;
+gap> r.success;
+true
+gap> SortedList(RecNames(r));
+[ "result", "success" ]
+gap> PositionSublist(r.result, "google") <> fail;
+true
+gap> PositionSublist(r.result, "tiger") <> fail;
+false
+
+# HEAD requests
+gap> CurlRequest("www.google.com", "HEAD" , "");
+rec( result := "", success := true )
+gap> r := CurlRequest("www.google.cheesebadger", "HEAD" , "");;
+gap> r.success;
+false
+
+# DELETE requests
+gap> r := DeleteURL("https://www.google.com");;
+gap> r.success;
+true
+gap> PositionSublist(r.result, "405 ") <> fail;
+true
+gap> PositionSublist(r.result, "tiger") <> fail;
+false
+gap> r := DeleteURL("httpbun.com/delete");;
+gap> r.success;
+true
+gap> PositionSublist(r.result, "405 ") <> fail;
+false
+
+# Check verbose requests don't break anything (we can't catch the output here)
+gap> r := DownloadURL("httpbun.com/get", rec(verbose := true));;
+gap> r.success;
+true
+gap> PositionSublist(r.result, "httpbun") <> fail;
+true
+
+#gap> PositionSublist(r.result, "404 ") <> fail;
+#false
+
+# Follow redirects
+gap> url := "http://www.icm.tu-bs.de/ag_algebra/software/polycyclic";;
+gap> r := DownloadURL(url);;
+gap> PositionSublist(r.result, "GitHub Pages") <> fail;
+true
+gap> r := DownloadURL(url, rec(followRedirect := true));;
+gap> PositionSublist(r.result, "GitHub Pages") <> fail;
+true
+gap> r := DownloadURL(url, rec(followRedirect := false));;
+gap> PositionSublist(r.result, "GitHub Pages") <> fail;
+false
+gap> PositionSublist(r.result, "301 ") <> fail;
+true
+
+# Check timeout works
+gap> CurlRequest("www.google.com", "HEAD" , "", rec(maxTime := 1000000));
+rec( result := "", success := true )

gap/pkg/curlinterface/tst/errors.tst

@@ -0,0 +1,65 @@
+#
+# test error handling
+#
+
+# URL too long (Download)
+gap> badURL := ListWithIdenticalEntries(4096,' ');;
+gap> DownloadURL(badURL);
+Error, CURL_REQUEST: <URL> must be less than 4096 chars
+
+# URL too long (Post)
+gap> badURL := ListWithIdenticalEntries(4096,' ');;
+gap> PostToURL(badURL, "hello");
+Error, CURL_REQUEST: <URL> must be less than 4096 chars
+
+# URL not a string (Download)
+gap> DownloadURL(42);
+Error, CurlRequest: <URL> must be a string
+
+# URL not a string (Post)
+gap> PostToURL(42, "hello");
+Error, CurlRequest: <URL> must be a string
+
+# request type not a string
+gap> CurlRequest("www.google.com", 637, "hello", rec(verifyCert := true));
+Error, CurlRequest: <type> must be a string
+
+# post_string not a string
+gap> PostToURL("httpbun.com/post", 17);
+Error, CurlRequest: <out_string> must be a string
+
+# invalid verifyCert
+gap> DownloadURL("https://www.google.com", rec(verifyCert := "maybe"));
+Error, CurlRequest: <opts>.verifyCert must be true or false
+
+# invalid verbose
+gap> DownloadURL("https://www.google.com", rec(verbose := "yes"));
+Error, CurlRequest: <opts>.verbose must be true or false
+
+# invalid followRedirect
+gap> DownloadURL("https://www.google.com", rec(followRedirect := "always"));
+Error, CurlRequest: <opts>.followRedirect must be true or false
+
+# invalid failOnError
+gap> DownloadURL("https://www.google.com", rec(failOnError := "yes"));
+Error, CurlRequest: <opts>.failOnError must be true or false
+
+# invalid opts
+gap> DownloadURL("https://www.google.com", "please verify the cert");
+Error, CurlRequest: <opts> must be a record
+
+# too many arguments
+gap> CurlRequest("www.google.com", "GET", "", rec(verifyCert := true), 3, true);
+Error, CurlRequest: usage: requires 3 or 4 arguments, but 6 were given
+
+# invalid time
+gap> CurlRequest("www.google.com", "GET", "", rec(maxTime := -1));
+Error, CurlRequest: <opts>.maxTime must be a non-negative integer
+
+# invalid time
+gap> CurlRequest("www.google.com", "GET", "", rec(maxTime := "abc"));
+Error, CurlRequest: <opts>.maxTime must be a non-negative integer
+
+# number of arguments
+gap> CURL_REQUEST();
+Error, Function: number of arguments must be 8 (not 0)

gap/pkg/curlinterface/tst/testall.g

@@ -0,0 +1,12 @@
+#
+# curlInterface: Simple Web Access
+#
+# This file runs package tests. It is also referenced in the package
+# metadata in PackageInfo.g.
+#
+LoadPackage( "curlInterface" );
+
+TestDirectory(DirectoriesPackageLibrary( "curlInterface", "tst" ),
+  rec(exitGAP := true));
+
+FORCE_QUIT_GAP(1); # if we ever get here, there was an error

passagemath_gap_pkg_curlinterface/__init__.py

@@ -0,0 +1,3 @@
+# sage_setup: distribution = sagemath-gap-pkg-curlinterface
+
+from sage.all__sagemath_gap_pkg_curlinterface import *

passagemath_gap_pkg_curlinterface-10.6.39.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: passagemath-gap-pkg-curlinterface
+Version: 10.6.39
+Summary: passagemath: Computational Group Theory with GAP: curlinterface package
+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
+Requires-Dist: passagemath-environment~=10.6.39.0
+
+=========================================================================
+ passagemath: Computational Group Theory with GAP: curlinterface package
+=========================================================================
+
+`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.13.x.
+
+
+About this pip-installable distribution package
+-----------------------------------------------
+
+This pip-installable distribution ``passagemath-gap-pkg-curlinterface`` is a
+distribution of the GAP package ``curlinterface`` for use with ``passagemath-gap``.
+
+
+What is included
+----------------
+
+- Wheels on PyPI include the GAP package ``curlinterface``