py/matplotlib, py/matplotlib/pyplot

chore/llpyg/llpyg.go

@@ -81,7 +81,7 @@ func main() {
 		log.Printf("import module %s failed\n", pyLib)
 		os.Exit(1)
 	}
-	pkg := gogen.NewPackage("", pyLib, nil)
+	pkg := gogen.NewPackage("", pkgName(pyLib), nil)
 	pkg.Import("unsafe").MarkForceUsed(pkg)       // import _ "unsafe"
 	py := pkg.Import("github.com/goplus/llgo/py") // import "github.com/goplus/llgo/py"
 
@@ -115,6 +115,13 @@ func main() {
 	pkg.WriteTo(os.Stdout)
 }
 
+func pkgName(pyLib string) string {
+	if pos := strings.LastIndexByte(pyLib, '.'); pos >= 0 {
+		return pyLib[pos+1:]
+	}
+	return pyLib
+}
+
 type context struct {
 	pkg    *gogen.Package
 	obj    *types.Named
@@ -127,7 +134,7 @@ type context struct {
 func (ctx *context) genMod(pkg *gogen.Package, mod *module) {
 	for _, sym := range mod.Items {
 		switch sym.Type {
-		case "builtin_function_or_method", "function", "ufunc", "method-wrapper":
+		case "builtin_function_or_method", "function", "method", "ufunc", "method-wrapper":
 			ctx.genFunc(pkg, sym)
 		case "str", "float", "bool", "type", "dict", "tuple", "list", "object", "module",
 			"int", "set", "frozenset", "flags", "bool_", "pybind11_type", "layout",
@@ -211,7 +218,7 @@ func genName(name string, idxDontTitle int) string {
 	}
 	name = strings.Join(parts, "")
 	switch name {
-	case "default", "func", "var", "":
+	case "default", "func", "var", "range", "":
 		name += "_"
 	}
 	return name

py/matplotlib/gen.go

@@ -0,0 +1,372 @@
+package matplotlib
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/py"
+)
+
+const LLGoPackage = "py.matplotlib"
+
+// Returns a new subclass of tuple with named fields.
+//
+//	>>> Point = namedtuple('Point', ['x', 'y'])
+//	>>> Point.__doc__                   # docstring for the new class
+//	'Point(x, y)'
+//	>>> p = Point(11, y=22)             # instantiate with positional args or keywords
+//	>>> p[0] + p[1]                     # indexable like a plain tuple
+//	33
+//	>>> x, y = p                        # unpack like a regular tuple
+//	>>> x, y
+//	(11, 22)
+//	>>> p.x + p.y                       # fields also accessible by name
+//	33
+//	>>> d = p._asdict()                 # convert to a dictionary
+//	>>> d['x']
+//	11
+//	>>> Point(**d)                      # convert from a dictionary
+//	Point(x=11, y=22)
+//	>>> p._replace(x=100)               # _replace() is like str.replace() but targets named fields
+//	Point(x=100, y=22)
+//
+//go:linkname Namedtuple py.namedtuple
+func Namedtuple(typename *py.Object, fieldNames *py.Object) *py.Object
+
+// Parse the given version string.
+//
+//	>>> parse('1.0.dev1')
+//	<Version('1.0.dev1')>
+//
+//	:param version: The version string to parse.
+//	:raises InvalidVersion: When the version string is not a valid version.
+//
+//go:linkname ParseVersion py.parse_version
+func ParseVersion(version *py.Object) *py.Object
+
+// Convert dictview objects to list. Other inputs are returned unchanged.
+//
+//go:linkname SanitizeSequence py.sanitize_sequence
+func SanitizeSequence(data *py.Object) *py.Object
+
+// Configure Matplotlib's logging levels.
+//
+// Matplotlib uses the standard library `logging` framework under the root
+// logger 'matplotlib'.  This is a helper function to:
+//
+//   - set Matplotlib's root logger level
+//   - set the root logger handler's level, creating the handler
+//     if it does not exist yet
+//
+// Typically, one should call “set_loglevel("info")“ or
+// “set_loglevel("debug")“ to get additional debugging information.
+//
+// Users or applications that are installing their own logging handlers
+// may want to directly manipulate “logging.getLogger('matplotlib')“ rather
+// than use this function.
+//
+// Parameters
+// ----------
+// level : {"notset", "debug", "info", "warning", "error", "critical"}
+//
+//	The log level of the handler.
+//
+// Notes
+// -----
+// The first time this function is called, an additional handler is attached
+// to Matplotlib's root handler; this handler is reused every time and this
+// function simply manipulates the logger and handler's level.
+//
+//go:linkname SetLoglevel py.set_loglevel
+func SetLoglevel(level *py.Object) *py.Object
+
+// Return the string path of the configuration directory.
+//
+// The directory is chosen as follows:
+//
+//  1. If the MPLCONFIGDIR environment variable is supplied, choose that.
+//  2. On Linux, follow the XDG specification and look first in
+//     “$XDG_CONFIG_HOME“, if defined, or “$HOME/.config“.  On other
+//     platforms, choose “$HOME/.matplotlib“.
+//  3. If the chosen directory exists and is writable, use that as the
+//     configuration directory.
+//  4. Else, create a temporary directory, and use it as the configuration
+//     directory.
+//
+//go:linkname GetConfigdir py.get_configdir
+func GetConfigdir() *py.Object
+
+// Return the string path of the cache directory.
+//
+// The procedure used to find the directory is the same as for
+// `get_configdir`, except using “$XDG_CACHE_HOME“/“$HOME/.cache“ instead.
+//
+//go:linkname GetCachedir py.get_cachedir
+func GetCachedir() *py.Object
+
+// Return the path to Matplotlib data.
+//
+//go:linkname GetDataPath py.get_data_path
+func GetDataPath() *py.Object
+
+// Get the location of the config file.
+//
+// # The file location is determined in the following order
+//
+// - “$PWD/matplotlibrc“
+// - “$MATPLOTLIBRC“ if it is not a directory
+// - “$MATPLOTLIBRC/matplotlibrc“
+// - “$MPLCONFIGDIR/matplotlibrc“
+// - On Linux,
+//   - “$XDG_CONFIG_HOME/matplotlib/matplotlibrc“ (if “$XDG_CONFIG_HOME“
+//     is defined)
+//   - or “$HOME/.config/matplotlib/matplotlibrc“ (if “$XDG_CONFIG_HOME“
+//     is not defined)
+//
+// - On other platforms,
+//   - “$HOME/.matplotlib/matplotlibrc“ if “$HOME“ is defined
+//   - Lastly, it looks in “$MATPLOTLIBDATA/matplotlibrc“, which should always
+//     exist.
+//
+//go:linkname MatplotlibFname py.matplotlib_fname
+func MatplotlibFname() *py.Object
+
+// Construct a `RcParams` instance from the default Matplotlib rc file.
+//
+//go:linkname RcParams py.rc_params
+func RcParams(failOnError *py.Object) *py.Object
+
+// Construct a `RcParams` from file *fname*.
+//
+// Parameters
+// ----------
+// fname : str or path-like
+//
+//	A file with Matplotlib rc settings.
+//
+// fail_on_error : bool
+//
+//	If True, raise an error when the parser fails to convert a parameter.
+//
+// use_default_template : bool
+//
+//	If True, initialize with default parameters before updating with those
+//	in the given file. If False, the configuration class only contains the
+//	parameters specified in the file. (Useful for updating dicts.)
+//
+//go:linkname RcParamsFromFile py.rc_params_from_file
+func RcParamsFromFile(fname *py.Object, failOnError *py.Object, useDefaultTemplate *py.Object) *py.Object
+
+// Set the current `.rcParams`.  *group* is the grouping for the rc, e.g.,
+// for “lines.linewidth“ the group is “lines“, for
+// “axes.facecolor“, the group is “axes“, and so on.  Group may
+// also be a list or tuple of group names, e.g., (*xtick*, *ytick*).
+// *kwargs* is a dictionary attribute name/value pairs, e.g.,::
+//
+//	rc('lines', linewidth=2, color='r')
+//
+// sets the current `.rcParams` and is equivalent to::
+//
+//	rcParams['lines.linewidth'] = 2
+//	rcParams['lines.color'] = 'r'
+//
+// The following aliases are available to save typing for interactive users:
+//
+// =====   =================
+// Alias   Property
+// =====   =================
+// 'lw'    'linewidth'
+// 'ls'    'linestyle'
+// 'c'     'color'
+// 'fc'    'facecolor'
+// 'ec'    'edgecolor'
+// 'mew'   'markeredgewidth'
+// 'aa'    'antialiased'
+// =====   =================
+//
+// Thus you could abbreviate the above call as::
+//
+//	rc('lines', lw=2, c='r')
+//
+// Note you can use python's kwargs dictionary facility to store
+// dictionaries of default parameters.  e.g., you can customize the
+// font rc as follows::
+//
+//	font = {'family' : 'monospace',
+//	        'weight' : 'bold',
+//	        'size'   : 'larger'}
+//	rc('font', **font)  # pass in the font dict as kwargs
+//
+// This enables you to easily switch between several configurations.  Use
+// “matplotlib.style.use('default')“ or :func:`~matplotlib.rcdefaults` to
+// restore the default `.rcParams` after changes.
+//
+// Notes
+// -----
+// Similar functionality is available by using the normal dict interface, i.e.
+// “rcParams.update({"lines.linewidth": 2, ...})“ (but “rcParams.update“
+// does not support abbreviations or grouping).
+//
+//go:linkname Rc py.rc
+func Rc(group *py.Object) *py.Object
+
+// Restore the `.rcParams` from Matplotlib's internal default style.
+//
+// Style-blacklisted `.rcParams` (defined in
+// “matplotlib.style.core.STYLE_BLACKLIST“) are not updated.
+//
+// See Also
+// --------
+// matplotlib.rc_file_defaults
+//
+//	Restore the `.rcParams` from the rc file originally loaded by
+//	Matplotlib.
+//
+// matplotlib.style.use
+//
+//	Use a specific style file.  Call ``style.use('default')`` to restore
+//	the default style.
+//
+//go:linkname Rcdefaults py.rcdefaults
+func Rcdefaults() *py.Object
+
+// Restore the `.rcParams` from the original rc file loaded by Matplotlib.
+//
+// Style-blacklisted `.rcParams` (defined in
+// “matplotlib.style.core.STYLE_BLACKLIST“) are not updated.
+//
+//go:linkname RcFileDefaults py.rc_file_defaults
+func RcFileDefaults() *py.Object
+
+// Update `.rcParams` from file.
+//
+// Style-blacklisted `.rcParams` (defined in
+// “matplotlib.style.core.STYLE_BLACKLIST“) are not updated.
+//
+// Parameters
+// ----------
+// fname : str or path-like
+//
+//	A file with Matplotlib rc settings.
+//
+// use_default_template : bool
+//
+//	If True, initialize with default parameters before updating with those
+//	in the given file. If False, the current configuration persists
+//	and only the parameters specified in the file are updated.
+//
+//go:linkname RcFile py.rc_file
+func RcFile(fname *py.Object) *py.Object
+
+// Return a context manager for temporarily changing rcParams.
+//
+// The :rc:`backend` will not be reset by the context manager.
+//
+// rcParams changed both through the context manager invocation and
+// in the body of the context will be reset on context exit.
+//
+// Parameters
+// ----------
+// rc : dict
+//
+//	The rcParams to temporarily set.
+//
+// fname : str or path-like
+//
+//	A file with Matplotlib rc settings. If both *fname* and *rc* are given,
+//	settings from *rc* take precedence.
+//
+// See Also
+// --------
+// :ref:`customizing-with-matplotlibrc-files`
+//
+// Examples
+// --------
+// Passing explicit values via a dict::
+//
+//	with mpl.rc_context({'interactive': False}):
+//	    fig, ax = plt.subplots()
+//	    ax.plot(range(3), range(3))
+//	    fig.savefig('example.png')
+//	    plt.close(fig)
+//
+// Loading settings from a file::
+//
+//	with mpl.rc_context(fname='print.rc'):
+//	    plt.plot(x, y)  # uses 'print.rc'
+//
+// Setting in the context body::
+//
+//	with mpl.rc_context():
+//	    # will be reset
+//	    mpl.rcParams['lines.linewidth'] = 5
+//	    plt.plot(x, y)
+//
+//go:linkname RcContext py.rc_context
+func RcContext(rc *py.Object, fname *py.Object) *py.Object
+
+// Select the backend used for rendering and GUI integration.
+//
+// If pyplot is already imported, `~matplotlib.pyplot.switch_backend` is used
+// and if the new backend is different than the current backend, all Figures
+// will be closed.
+//
+// Parameters
+// ----------
+// backend : str
+//
+//	The backend to switch to.  This can either be one of the standard
+//	backend names, which are case-insensitive:
+//
+//	- interactive backends:
+//	  GTK3Agg, GTK3Cairo, GTK4Agg, GTK4Cairo, MacOSX, nbAgg, QtAgg,
+//	  QtCairo, TkAgg, TkCairo, WebAgg, WX, WXAgg, WXCairo, Qt5Agg, Qt5Cairo
+//
+//	- non-interactive backends:
+//	  agg, cairo, pdf, pgf, ps, svg, template
+//
+//	or a string of the form: ``module://my.module.name``.
+//
+//	Switching to an interactive backend is not possible if an unrelated
+//	event loop has already been started (e.g., switching to GTK3Agg if a
+//	TkAgg window has already been opened).  Switching to a non-interactive
+//	backend is always possible.
+//
+// force : bool, default: True
+//
+//	If True (the default), raise an `ImportError` if the backend cannot be
+//	set up (either because it fails to import, or because an incompatible
+//	GUI interactive framework is already running); if False, silently
+//	ignore the failure.
+//
+// See Also
+// --------
+// :ref:`backends`
+// matplotlib.get_backend
+// matplotlib.pyplot.switch_backend
+//
+//go:linkname Use py.use
+func Use(backend *py.Object) *py.Object
+
+// Return the name of the current backend.
+//
+// See Also
+// --------
+// matplotlib.use
+//
+//go:linkname GetBackend py.get_backend
+func GetBackend() *py.Object
+
+// Set whether to redraw after every plotting command (e.g. `.pyplot.xlabel`).
+//
+//go:linkname Interactive py.interactive
+func Interactive(b *py.Object) *py.Object
+
+// Return whether to redraw after every plotting command.
+//
+// .. note::
+//
+//	This function is only intended for use in backends. End users should
+//	use `.pyplot.isinteractive` instead.
+//
+//go:linkname IsInteractive py.is_interactive
+func IsInteractive() *py.Object