h)                    ! " # $ % & ' ( ) * + , - ./0123456789: ; < = > ? @ A B C D E F G HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                      !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""#3.8.0$$ Safe-Inferred6e     Safe-Inferred cpython The Python True object. The Python None object, denoting lack of value.cpython The Python False object.  Safe-Inferred?cpythonInitialize the Python interpreter. In an application embedding Python, this should be called before using any other Python/C API computations; with the exception of !,  initThreads,  releaseLock, and  acquireLock1. This initializes the table of loaded modules ( sys.modules(), and creates the fundamental modules builtins, main and sys/. It also initializes the module search path (sys.path). It does not set sys.argv; use + for that. This is a no-op when called for a second time (without calling  first). There is no return value; it is a fatal error if the initialization fails.Return 3 when the Python interpreter has been initialized,  if not. After  is called, this returns  until  is called again.cpython!Undo all initializations made by  and subsequent use of Python/C API computations, and destroy all sub-interpreters (see  below) that were created and not yet destroyed since the last call to . Ideally, this frees all memory allocated by the Python interpreter. This is a no-op when called for a second time (without calling  again first). There is no return value; errors during finalization are ignored.This computation is provided for a number of reasons. An embedding application might want to restart Python without having to restart the application itself. An application that has loaded the Python interpreter from a dynamically loadable library (or DLL) might want to free all memory allocated by Python before unloading the DLL. During a hunt for memory leaks in an application a developer might want to free all memory allocated by Python before exiting from the application.Bugs and caveats: The destruction of modules and objects in modules is done in arbitrary order; this may cause destructors (del() methods) to fail when they depend on other objects (even functions) or modules. Dynamically loaded extension modules loaded by Python are not unloaded. Small amounts of memory allocated by the Python interpreter may not be freed (if you find a leak, please report it). Memory tied up in circular references between objects is not freed. Some memory allocated by extension modules may not be freed. Some extensions may not work properly if their initialization routine is called more than once; this can happen if an application calls  and  more than once.cpythonCreate a new sub-interpreter. This is an (almost) totally separate environment for the execution of Python code. In particular, the new interpreter has separate, independent versions of all imported modules, including the fundamental modules builtins, main and sys . The table of loaded modules ( sys.modules) and the module search path (sys.path0) are also separate. The new environment has no sys.argv8 variable. It has new standard I/O stream file objects  sys.stdin,  sys.stdout and  sys.stderr. (however these refer to the same underlying FILE structures in the C library).The return value points to the first thread state created in the new sub-interpreter. This thread state is made in the current thread state. Note that no actual thread is created; see the discussion of thread states below. If creation of the new interpreter is unsuccessful,  is returned; no exception is set since the exception state is stored in the current thread state and there may not be a current thread state. (Like all other Python/C API computations, the global interpreter lock must be held before calling this computation and is still held when it returns; however, unlike most other Python/C API computations, there needn@t be a current thread state on entry.)Extension modules are shared between (sub-)interpreters as follows: the first time a particular extension is imported, it is initialized normally, and a (shallow) copy of its module@s dictionary is squirreled away. When the same extension is imported by another (sub-)interpreter, a new module is initialized and filled with the contents of this copy; the extension@s init procedure is not called. Note that this is different from what happens when an extension is imported after the interpreter has been completely re-initialized by calling  and  ; in that case, the extension@s initmodule procedure is called again.Bugs and caveats: Because sub-interpreters (and the main interpreter) are part of the same process, the insulation between them isn@t perfect @ for example, using low-level file operations like  os.close() they can (accidentally or maliciously) affect each other@s open files. Because of the way extensions are shared between (sub-)interpreters, some extensions may not work properly; this is especially likely when the extension makes use of (static) global variables, or when the extension manipulates its module@s dictionary after its initialization. It is possible to insert objects created in one sub-interpreter into a namespace of another sub-interpreter; this should be done with great care to avoid sharing user-defined functions, methods, instances or classes between sub-interpreters, since import operations executed by such objects may affect the wrong (sub-)interpreter@s dictionary of loaded modules. (XXX This is a hard-to-fix bug that will be addressed in a future release.)Also note that the use of this functionality is incompatible with extension modules such as PyObjC and ctypes that use the PyGILState_*(), APIs (and this is inherent in the way the PyGILState_*() procedures work). Simple things may work, but confusing behavior will always be near.cpythonDestroy the (sub-)interpreter represented by the given thread state. The given thread state must be the current thread state. See the discussion of thread states below. When the call returns, the current thread state is NULL. All thread states associated with this interpreter are destroyed. (The global interpreter lock must be held before calling this computation and is still held when it returns.)  will destroy all sub-interpreters that haven@t been explicitly destroyed at that point. cpython!Return the program name set with !, or the default.!cpython)This computation should be called before  is called for the first time, if it is called at all. It tells the interpreter the value of the argv[0] argument to the main, procedure of the program. This is used by % and some other computations below to find the Python run-time libraries relative to the interpreter executable. The default value is "python". No code in the Python interpreter will change the program name."cpythonReturn the prefix for installed platform-independent files. This is derived through a number of complicated rules from the program name set with ! and some environment variables; for example, if the program name is "/usr/local/bin/python", the prefix is  "/usr/local". This corresponds to the prefix- variable in the top-level Makefile and the --prefix argument to the  configure script at build time. The value is available to Python code as  sys.prefix'. It is only useful on UNIX. See also #.#cpython Return the  exec-prefix for installed platform- dependent files. This is derived through a number of complicated rules from the program name set with setProgramName' and some environment variables; for example, if the program name is "/usr/local/bin/python", the exec-prefix is  "/usr/local". This corresponds to the  exec_prefix- variable in the top-level Makefile and the  --exec-prefix argument to the  configure script at build time. The value is available to Python code as sys.exec_prefix. It is only useful on UNIX.Background: The exec-prefix differs from the prefix when platform dependent files (such as executables and shared libraries) are installed in a different directory tree. In a typical installation, platform dependent files may be installed in the /usr/local/plat9 subtree while platform independent may be installed in  /usr/local.Generally speaking, a platform is a combination of hardware and software families, e.g. Sparc machines running the Solaris 2.x operating system are considered the same platform, but Intel machines running Solaris 2.x are another platform, and Intel machines running Linux are yet another platform. Different major revisions of the same operating system generally also form different platforms. Non-UNIX operating systems are a different story; the installation strategies on those systems are so different that the prefix and exec-prefix are meaningless, and set to the empty string. Note that compiled Python bytecode files are platform independent (but not independent from the Python version by which they were compiled!).5System administrators will know how to configure the mount or  automount programs to share  /usr/local! between platforms while having /usr/local/plat- be a different filesystem for each platform.$cpythonReturn the full program name of the Python executable; this is computed as a side-effect of deriving the default module search path from the program name (set by !3 above). The value is available to Python code as sys.executable.%cpythonReturn the default module search path; this is computed from the program name (set by ! above) and some environment variables. The returned string consists of a series of directory names separated by a platform dependent delimiter character. The delimiter character is ':' on Unix and Mac OS X, ';' on Windows. The value is available to Python code as the list sys.path, which may be modified to change the future search path for loaded modules.&cpythonReturn the version of this Python interpreter. This is a string that looks something like = "3.0a5+ (py3k:63103M, May 12 2008, 00:53:55) \n[GCC 4.2.3]" The first word (up to the first space character) is the current Python version; the first three characters are the major and minor version separated by a period. The value is available to Python code as  sys.version.'cpythonReturn the platform identifier for the current platform. On Unix, this is formed from the @official@ name of the operating system, converted to lower case, followed by the major revision number; e.g., for Solaris 2.x, which is also known as SunOS 5.x, the value is "sunos5". On Mac OS X, it is "darwin". On Windows, it is "win",. The value is available to Python code as  sys.platform.(cpythonReturn the official copyright string for the current Python version, for example  "Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam" )The value is available to Python code as  sys.copyright.)cpythonReturn an indication of the compiler used to build the current Python version, in square brackets, for example:  "[GCC 2.7.2.2]" ?The value is available to Python code as part of the variable  sys.version.*cpythonReturn information about the sequence number and build date and time of the current Python interpreter instance, for example  "#67, Aug 1 1997, 22:34:28" ?The value is available to Python code as part of the variable  sys.version.+cpythonSet sys.argv3. The first parameter is similar to the result of  getProgName, with the difference that it should refer to the script file to be executed rather than the executable hosting the Python interpreter. If there isn@t a script that will be run, the first parameter can be an empty string. If this function fails to initialize sys.argv', a fatal condition is signalled using Py_FatalError().;This function also prepends the executed script@s path to sys.path3. If no script is executed (in the case of calling  python -c or just the interactive interpreter), the empty string is used instead.,cpythonReturn the default @home@, that is, the value set by a previous call to -, or the value of the  PYTHONHOME$ environment variable if it is set.-cpythonSet the default @home@ directory, that is, the location of the standard Python libraries. The libraries are searched in home/lib/python version and home/lib/python version. No code in the Python interpreter will change the Python home. !"#$%&'()*+,- !"#$%&'()*+,- Safe-Inferred@E.cpython*Attempt to convert an object to a generic . If the object does not implement the iterator protocol, returns ./cpython-Return the next value from the iteration, or " if there are no remaining items.././ Safe-Inferred@u 012345678 012345678  Safe-Inferred@:@?>=<;:@?>=<;  Safe-InferredDBcpython Return a  of the builtins in the current execution frame, or the interpreter of the thread state if no frame is currently executing. Return a < of the local variables in the current execution frame, or $ if no frame is currently executing.Dcpython Return a = of the global variables in the current execution frame, or $ if no frame is currently executing.Ecpython2Return the current thread state's frame, which is % if no frame is currently executing.FcpythonReturn the name of func if it is a function, class or instance object, else the name of func's type.GcpythonReturn a description string, depending on the type of func. Return values include "()" for functions and methods,  "constructor",  "instance", and "object"#. Concatenated with the result of F&, the result will be a description of func.BCDEFGBCDEFG Safe-InferredFHcpythonReturn the object name from the sys module, or  if it does not exist.IcpythonSet name in the sys module to a value.JcpythonDelete name from the sys module.KcpythonAdd an entry to sys.warnoptions.Reset sys.warnoptions to an empty list.McpythonSet sys.path to a list object of paths found in the parameter, which should be a list of paths separated with the platform's search path delimiter (':' on Unix, ';' on Windows).HIJKLMHIJKLM Safe-InferredG}RcpythonCreate a new byte array from any object which implements the buffer protocol.NOPQRSTUNOPQRSTU Safe-InferredH\cpythonCreate a new byte string from any object which implements the buffer protocol.XYZ[\]^XYZ[\]^ Safe-InferredNccpythonRetrieve the pointer stored in the capsule. On failure, throws an exception.The name parameter must compare exactly to the name stored in the capsule. If the name stored in the capsule is #, the name passed in must also be . Python uses the C function strcmp() to compare capsule names.dcpythonReturn the current context stored in the capsule, which might be NULL.ecpython>Return the current name stored in the capsule, which might be .fcpythonImport a pointer to a C object from a capsule attribute in a module. The name parameter should specify the full name to the attribute, as in "module.attribute". The name stored in the capsule must match this string exactly. If the second parameter is -, import the module without blocking (using PyImport_ImportModuleNoBlock()8). Otherwise, imports the module conventionally (using PyImport_ImportModule()).Return the capsule@s internal pointer on success. On failure, throw an exception. If the module could not be imported, and if importing in non-blocking mode, returns .gcpythonDetermines whether or not a capsule is valid. A valid capsule's type is b, has a non-NULL pointer stored in it, and its internal name matches the name parameter. (See c5 for information on how capsule names are compared.)In other words, if g returns =, calls to any of the accessors (any function starting with get) are guaranteed to succeed.hcpythonSet the void pointer inside the capsule. The pointer may not be NULL.icpython+Set the context pointer inside the capsule. abcdefghi abcdefghi Safe-InferredPncpython2Create and return a new cell containing the value obj.ocpythonReturn the contents of a cell.pcpythonSet the contents of a cell to obj. This releases the reference to any current content of the cell.lmnoplmnop Safe-InferredP3stst Safe-InferredP]wxyzwxyz Safe-InferredY. cpython4Empty an existing dictionary of all key-value pairs.cpython#Determine if a dictionary contains key(. If an item in the dictionary matches key , return , otherwise return . On error, throws an exception. This is equivalent to the Python expression key in d.cpythonReturn a new dictionary that contains the same key-value pairs as the old dictionary.cpython4Return the object from a dictionary which has a key key . Return  if the key is not present.cpythonInserts value! into a dictionary with a key of key. key( must be hashable; if it isn@t, throws  TypeError.cpython*Remove the entry in a dictionary with key key. key( must be hashable; if it isn@t, throws  TypeError.cpython Return a  containing all the items in the dictionary, as in the Python method  dict.items().cpython Return a  containing all the keys in the dictionary, as in the Python method  dict.keys().cpython Return a  containing all the values in the dictionary, as in the Python method  dict.values().cpythonReturn the number of items in the dictionary. This is equivalent to len(d).cpythonIterate over mapping object b* adding key-value pairs to a dictionary. b/ may be a dictionary, or any object supporting  and . If the third parameter is , existing pairs in will be replaced if a matching key is found in b, otherwise pairs will only be added if there is not already a matching key.cpythonThis is the same as  (\a b ->  a b True) in Haskell, or  a.update(b) in Python.cpython?Update or merge into a dictionary, from the key-value pairs in seq2. seq2 must be an iterable object producing iterable objects of length 2, viewed as key-value pairs. In case of duplicate keys, the last wins if the third parameter is /, otherwise the first wins. Equivalent Python: def mergeFromSeq2(a, seq2, override): for key, value in seq2: if override or key not in a: a[key] = value }~}~ Safe-InferredY   Safe-InferredY Safe-Inferred^h cpythonReturn a new function associated with the given code object. The second parameter will be used as the globals accessible to the function.$The function's docstring, name, and module are retrieved from the code object. The parameter defaults and closure are set to .cpython2Return the code object associated with a function.cpython9Return the globals dictionary associated with a function.cpython Return the module. attribute of a function. This is normally a Unicode containing the module name, but can be set to any other object by Python code.cpythonReturn the default parameter values for a function. This can be a tuple or .cpython&Set the default values for a function.cpython;Return the closure associated with a function. This can be , or a tuple of Cells.cpythonSet the closure associated with a function. The tuple should contain Cells.cpythonReturn the annotations for a function. This can be a mutable dictionary, or .cpython*Set the annotations for a function object.   Safe-Inferred^ Safe-Inferred`cpython Return an , that works with a general sequence object, seq/. The iteration ends when the sequence raises  IndexError! for the subscripting operation.cpython Return a new . The first parameter, callable, can be any Python callable object that can be called with no parameters; each call to it should return the next item in the iteration. When callable returns a value equal to sentinel#, the iteration will be terminated. Safe-Inferreda Safe-Inferredc$cpython5Return a new slice object with the given values. The start, stop, and step parameters are used as the values of the slice object attributes of the same names. Any of the values may be , in which case None. will be used for the corresponding attribute.cpython8Retrieve the start, stop, step, and slice length from a +, assuming a sequence of the given length.cpythonSequence length Safe-Inferreddcpython;Convert any object implementing the iterator protocol to a  .cpython;Return the object at a given index from a tuple, or throws  IndexError if the index is out of bounds.cpythonTake a slice of a tuple from low to high , and return it as a new tuple.   Safe-Inferredjcpython Return a new " from the contents of an iterable . The object may be " to create an empty set. Throws a  TypeError if the object is not iterable.cpython Return a new " from the contents of an iterable . The object may be ) to create an empty frozen set. Throws a  TypeError if the object is not iterable.cpythonReturn the size of a  or .cpythonReturn  if found, " if not found. Unlike the Python contains() method, this computation does not automatically convert unhashable s into temporary  s. Throws a  TypeError if the key is unhashable.cpythonAdd key to a . Also works with  (like %4 it can be used to fill-in the values of brand new 4s before they are exposed to other code). Throws a  TypeError$ if the key is unhashable. Throws a  MemoryError if there is no room to grow.cpythonReturn  if found and removed, 1 if not found (no action taken). Does not throw KeyError for missing keys. Throws a  TypeError if key" is unhashable. Unlike the Python  discard() method, this computation does not automatically convert unhashable sets into temporary s.cpythonReturn an arbitrary object in the set, and removes the object from the set. Throws KeyError if the set is empty.cpythonRemove all elements from a set. Safe-InferredqR cpython;Convert any object implementing the iterator protocol to a .cpythonReturns the object at a given position in the list. The position must be positive; indexing from the end of the list is not supported. If the position is out of bounds, throws an  IndexError exception.cpythonSet the item at a given index.cpythonInserts item into the list in front of the given index. Throws an exception if unsuccessful. Analogous to list.insert(index, item).cpythonAppend item to the end of th list. Throws an exception if unsuccessful. Analogous to list.append(item).cpythonReturn a list of the objects in list containing the objects between the given indexes. Throws an exception if unsuccessful. Analogous to list[low:high]. Negative indices, as when slicing from Python, are not supported.cpython!Sets the slice of a list between low and high6 to the contents of a replacement list. Analogous to list[low:high] = replacement. The replacement may be , indicating the assignment of an empty list (slice deletion). Negative indices, as when slicing from Python, are not supported.cpython9Sort the items of a list in place. This is equivalent to  list.sort().cpython>Reverses the items of a list in place. This is equivalent to list.reverse().cpython Return a new  3 containing the contents of a list; equivalent to  tuple(list).cpythonLowcpythonHighcpython Replacement Safe-InferredrcpythonReturns > if the first parameter is a subtype of the second parameter. Safe-Inferred~cpythonCoerce an encoded object obj to an Unicode object.X and other char buffer compatible objects are decoded according to the given encoding and error handling mode.All other objects, including  objects, cause a  TypeError to be thrown.cpython Shortcut for  "utf-8" cpython Encode a ! object and return the result as X object. The encoding and error mode have the same meaning as the parameters of the the  str.encode() method. The codec to be used is looked up using the Python codec registry.cpython Create a  object by decoding a X object. The encoding and error mode have the same meaning as the parameters of the the  str.encode() method. The codec to be used is looked up using the Python codec registry.cpythonSplit a string giving a  of  objects. If the separator is , splitting will be done at all whitespace substrings. Otherwise, splits occur at the given separator. Separators are not included in the resulting list.cpythonSplit a , string at line breaks, returning a list of  strings. CRLF is considered to be one line break. If the second parameter is , the line break characters are not included in the resulting strings.cpython?Translate a string by applying a character mapping table to it.The mapping table must map Unicode ordinal integers to Unicode ordinal integers or None% (causing deletion of the character).%Mapping tables need only provide the getitem() interface; dictionaries and sequences work well. Unmapped character ordinals (ones which cause a  LookupError*) are left untouched and are copied as-is.0The error mode has the usual meaning for codecs.cpython5Join a sequence of strings using the given separator.cpythonReturn  if the substring matches string*[*start:end]" at the given tail end (either a  or  match),  otherwise.cpython.Return the first position of the substring in string*[*start:end] using the given direction. The return value is the index of the first match; a value of # indicates that no match was found.cpythonReturn the number of non-overlapping occurrences of the substring in string[start:end].cpythonReplace occurrences of the substring with a given replacement. If the maximum count is , replace all occurences.cpython Return a new > object from the given format and args; this is analogous to  format % args.cpythonCheck whether element is contained in a string.element' has to coerce to a one element string.cpython SeparatorcpythonMaximum splitscpythonStringcpython SubstringcpythonStartcpythonEndcpythonStringcpython SubstringcpythonStartcpythonEndcpythonStringcpython SubstringcpythonStartcpythonEndcpythonStringcpython Substringcpython Replacementcpython Maximum count Safe-Inferredrcpython*Attempt to convert an object to a generic . If the object does not implement the sequence protocol, returns .cpythonReturn the first index i for which  self[i] == v/. This is equivalent to the Python expression  self.index(v).cpythonReturn a list object with the same contents as the arbitrary sequence seq,. The returned list is guaranteed to be new.cpythonReturn a tuple object with the same contents as the arbitrary sequence seq. If seq6 is already a tuple, it is re-used rather than copied.cpythonReturns the sequence seq as a tuple, unless it is already a tuple or list, in which case seq* is returned. If an error occurs, throws  TypeError+ with the given text as the exception text.  Safe-Inferredcpython Returns a , object corresponding to the object type of self. On failure, throws  SystemError/. This is equivalent to the Python expression type(o).cpythonReturns  if inst is an instance of the class cls or a subclass of cls, or , if not. On error, throws an exception. If cls. is a type object rather than a class object,  returns  if inst is of type cls. If cls< is a tuple, the check will be done against every entry in cls. The result will be * when at least one of the checks returns , otherwise it will be . If inst is not a class instance and cls= is neither a type object, nor a class object, nor a tuple, inst must have a class attribute  the class relationship of the value of that attribute with cls8 will be used to determine the result of this function.Subclass determination is done in a fairly straightforward way, but includes a wrinkle that implementors of extensions to the class system may want to be aware of. If A and B are class objects, B is a subclass of A if it inherits from A either directly or indirectly. If either is not a class object, a more general mechanism is used to determine the class relationship of the two objects. When testing if B is a subclass of A, if A is B,  returns ). If A and B are different objects, Bs bases attribute is searched in a depth-first fashion for A  the presence of the bases< attribute is considered sufficient for this determination.cpythonReturns  if the class derived, is identical to or derived from the class cls, otherwise returns 0. In case of an error, throws an exception. If cls< is a tuple, the check will be done against every entry in cls. The result will be * when at least one of the checks returns , otherwise it will be  . If either derived or cls is not an actual class object (or tuple), this function uses the generic algorithm described above.cpythonAttempt to cast an object to some concrete class. If the object isn't an instance of the class or subclass, returns .cpythonReturns  if self, has an attribute with the given name, and 9 otherwise. This is equivalent to the Python expression hasattr(self, name)cpython6Retrieve an attribute with the given name from object self. Returns the attribute value on success, and throws an exception on failure. This is the equivalent of the Python expression  self.name.cpython?Set the value of the attribute with the given name, for object self, to the value v. THrows an exception on failure. This is the equivalent of the Python statement  self.name = v.cpython4Delete an attribute with the given name, for object self. Throws an exception on failure. This is the equivalent of the Python statement  del self.name.cpythonPrint  repr(self) to a handle.cpython*Compute a string representation of object self, or throw an exception on failure. This is the equivalent of the Python expression  repr(self).cpython*Compute a string representation of object self, or throw an exception on failure. This is the equivalent of the Python expression  str(self).cpython)Compute a bytes representation of object self, or throw an exception on failure. This is equivalent to the Python expression  bytes(self).cpythonDetermine if the object self is callable.cpythonCall a callable Python object self, with arguments given by the tuple and named arguments given by the dictionary. Returns the result of the call on success, or throws an exception on failure. This is the equivalent of the Python expression self(*args, **kw).cpythonCall a callable Python object self#, with arguments given by the list.cpython Call the named method of object self, with arguments given by the tuple and named arguments given by the dictionary. Returns the result of the call on success, or throws an exception on failure. This is the equivalent of the Python expression self.method(args).cpython Call the named method of object self, with arguments given by the list. Returns the result of the call on success, or throws an exception on failure. This is the equivalent of the Python expression self.method(args).cpythonCompare the values of a and b using the specified comparison. If an exception is raised, throws an exception.cpythonReturns  if the object self is considered to be true, and 9 otherwise. This is equivalent to the Python expression  not not self#. On failure, throws an exception.cpython/Compute and return the hash value of an object self. On failure, throws an exception. This is the equivalent of the Python expression  hash(self).cpython,This is equivalent to the Python expression  dir(self), returning a (possibly empty) list of strings appropriate for the object argument, or throws an exception if there was an error.cpython,This is equivalent to the Python expression  iter(self). It returns a new iterator for the object argument, or the object itself if the object is already an iterator. Throws  TypeError# if the object cannot be iterated."" Safe-Inferred Safe-Inferred cpython$Return a new module object with the name# attribute set. Only the module@s doc and name attributes are filled in; the caller is responsible for providing a file attribute.cpythonReturn the dictionary object that implements a module@s namespace; this object is the same as the dict attribute of the module. This computation never fails. It is recommended extensions use other computations rather than directly manipulate a module@s dict.cpythonReturns a module@s name value. If the module does not provide one, or if it is not a string, throws  SystemError.cpythonReturns the name of the file from which a module was loaded using the module@s file attribute. If this is not defined, or if it is not a string, throws  SystemError.cpythonAdd an object to a module with the given name. This is a convenience computation which can be used from the module@s initialization computation.cpythonAdd an integer constant to a module. This convenience computation can be used from the module@s initialization computation.cpythonAdd a string constant to a module. This convenience computation can be used from the module@s initialization computation.cpythonThis is a higher-level interface that calls the current @import hook@ (with an explicit level of 0,, meaning absolute import). It invokes the import() computation from the builtins of the current globals. This means that the import is done using whatever import hooks are installed in the current environment..This computation always uses absolute imports.cpythonReload a module. If an error occurs, an exception is thrown and the old module still exists.   Safe-InferredF$$  Safe-InferredcpythonReturn a weak reference for the object. This will always return a new reference, but is not guaranteed to create a new object; an existing reference object may be returned. The second parameter, callback<, can be a callable object that receives notification when obj is garbage collected; it should accept a single parameter, which will be the weak reference object itself. If ob is not a weakly-referencable object, or if callback$ is not callable, this will throw a  TypeError.cpythonReturn a weak reference proxy for the object. This will always return a new reference, but is not guaranteed to create a new object; an existing proxy may be returned. The second parameter, callback<, can be a callable object that receives notification when obj is garbage collected; it should accept a single parameter, which will be the weak reference object itself. If ob is not a weakly-referencable object, or if callback% is not callable, this will throw a  TypeError.cpythonReturn the referenced object from a weak reference. If the referent is no longer live, returns None.& Safe-InferredNXalsw  OYbmtx}PQZ[yzNXalsw  OYbmtx}PQZ[yz! Safe-Inferred" cpythonAn exception representing a failed cast from a Python object to Haskell value, usually because the expected type of the Python object was not correct. Carries a  which represents the name of the expected Haskell type which caused a failed cast. If using , this  is found with cpython instances indicate that a type can be marshalled from Python to Haskell automatically For example, FromPy Integer indicates that we know how to take some Python object and convert it into a Haskell Integer. If the Python object is int2, then we can cast properly. Failed casts throw a cpythonTakes some Python object, and converts it to the corresponding Haskell type by going over FFI. Might throw a #Generally you'll only need to call - manually on some type when writing your own  instances for another typecpython instances indicate that a type can be marshalled from Haskell to Python automatically For example,  ToPy Integer. indicates that we know how to take a Haskell  and convert it into a Python int objectcpythonTakes some Haskell type, and converts it to a Python object by going over FFI#Generally you'll only need to call - manually on some type when writing your own  instances for another typecpythonHelper that lets you convert a Haskell value to a Python object by providing both a Python conversion function (from the Haskell type, over FFI, to some Python Object) as well as the Haskell valueLets you define ' with just a Python conversion functioncpythonHelper that takes a conversion function and a Python object, and casts the Python object into a Haskell value.Lets you define ' with just a Python conversion functionWe use  to infer the type name for use in case of a failed cast. In the context of defining an instance, this type will be inferrable, so you can just provide a  valuecpython&python to- conversion, e.g. Py.toFloatcpythonhaskell type being convertedcpython Python objectcpython*python from- conversion, e.g. Py.fromFloatcpython%proxy for the type being converted tocpythonpython object to cast fromcpython Haskell value" Safe-Inferred"icpython2Representation of an argument to a Python functionThis lets us use various Haskell types in the same list of arguments. For example: sampleArgs :: [Arg] sampleArgs = [ arg (7 :: Integer) , arg ("hello" :: Text) ] cpython6Builds a Python argument from any Haskell type with a  instancecpythonKicks off talking to Python, and will need to be called before using other functionscpython4Given a Python module name as text, imports it as a Throws an exception if e.g. the module name was misspelled, or isn't installedcpythonThe most common use case of  ' is calling some Python function+For example, if we wanted to wrap Python's random.randint(low, high), we could write this: randint :: Integer -> Integer -> IO Integer randint low high = call "random" "randint" [arg low, arg high] [] Because of the  instance in 's type signature, we can infer what to do to convert a Python value back into Haskell, if given the type. In this example using random.uniform., although we use a similar definition as for randint, we correct cast to  instead of  uniform :: Integer -> Integer -> IO Double uniform low high = call "random" "uniform" [arg low, arg high] [] We can also use the TypeApplications language extension to tell  what type to use, if needed 7call @Double "random" "uniform" [arg low, arg high] [] Calling a function with mixed positional and keyword arguments is also fairly straightforward.%The example is equivalent to calling (pyautogui.moveTo(x, y, duration=seconds) moveToDuration :: Integer -> Integer -> Double -> IO () moveToDuration x y seconds = call "pyautogui" "moveTo" [arg x, arg y] [("duration", arg seconds)] cpython3Set the value of an attribute of some Python module&This example is equivalent to setting random.BPF = n in Python setBpf :: Integer -> IO () setBpf n = setAttribute "random" "BPF" n cpython3Get the value of an attribute of some Python module&This example is equivalent to getting  random.BPF in Python :getBpf :: IO Integer getBpf = getAttribute "random" "BPF" cpythonPython module namecpythonPython function namecpythonPython function's argumentscpython0Python function's keyword arguments (kwargs) as  (name, value) pairscpython module namecpythonattribute namecpythonvalue to set attribute tocpython module namecpythonattribute name$($)$*$+$,$-$.$/$0$1$2$3$4$5$6$7$8$9$:$;$< = > ? @ A B C D E F G H I J K L M N O P Q R S T UVWXY%Z[\]^_` a b c d e f g h i j k l m nopqrstuvwxyz{|}~y{zY%Z_]^[k{Y%[{Y%z{yz{zY%Z                                    o  !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""C"""""$$$$$$$$$$<$8$7$6$5$$$$$$$$$$$1$$$$$0$$-$$*$"cpython-3.8.0-inplaceCPython.Protocols.IteratorCPython.Protocols.SequenceCPython.Protocols.MappingCPython.Types.ExceptionCPython.Types.TupleCPython.Types.ListCPython.Types.DictionaryCPython.Types.TypeCPython.Protocols.ObjectCPython.ConstantsCPythonCPython.Protocols.Object.EnumsCPython.ReflectionCPython.SystemCPython.Types.ByteArrayCPython.Types.BytesCPython.Types.CapsuleCPython.Types.CellCPython.Types.CodeCPython.Types.ComplexCPython.Types.FloatCPython.Types.FunctionCPython.Types.InstanceMethodCPython.Types.IteratorCPython.Types.MethodCPython.Types.SliceCPython.Types.SetCPython.Types.UnicodeCPython.Types.IntegerCPython.Types.ModuleCPython.Protocols.NumberCPython.Types.WeakReferenceCPython.Simple.InstancesCPython.SimplecpythonCPython.InternalsetItem CPython.TypesSimpleIterator toIterator SomeIteratorSequence toSequence SomeSequenceMapping toMapping SomeMapping Exception exceptionTypeexceptionValueexceptionTracebackTupleList DictionaryTypeConcreteObjecttoObject SomeObjectnonetruefalseisNoneisTrueisFalse initialize isInitializedfinalizenewInterpreterendInterpretergetProgramNamesetProgramName getPrefix getExecPrefixgetProgramFullPathgetPath getVersion getPlatform getCopyright getCompiler getBuildInfosetArgv getPythonHome setPythonHomecastToIteratornext castToMappinggetItem deleteItemsizehasKeykeysvaluesitems$fMappingDictionaryHSCPythonComparisonEnum HSCPYTHON_LT HSCPYTHON_LE HSCPYTHON_EQ HSCPYTHON_NE HSCPYTHON_GT HSCPYTHON_GE$fEnumHSCPythonComparisonEnum getBuiltins getLocals getGlobalsgetFramegetFunctionNamegetFunctionDescription getObject setObject deleteObjectresetWarnOptions addWarnOptionsetPath ByteArray byteArrayType toByteArray fromByteArray fromObjectappendlengthresize$fConcreteByteArray$fObjectByteArrayBytes bytesTypetoBytes fromBytes$fConcreteBytes $fObjectBytesCapsule capsuleType getPointer getContextgetName importNamedisValid setPointer setContext$fConcreteCapsule$fObjectCapsuleCellcellTypenewgetset$fConcreteCell $fObjectCellCodecodeType$fConcreteCode $fObjectCodeComplex complexType toComplex fromComplex$fConcreteComplex$fObjectComplexdictionaryTypeclearcontainscopymergeupdate mergeFromSeq2$fConcreteDictionaryFloat floatTypetoFloat fromFloat$fConcreteFloat $fObjectFloatFunction functionTypegetCode getModule getDefaults setDefaults getClosure setClosuregetAnnotationssetAnnotations$fConcreteFunction$fObjectFunctionInstanceMethodinstanceMethodTypefunction$fConcreteInstanceMethod$fObjectInstanceMethodCallableIteratorSequenceIteratorsequenceIteratorTypecallableIteratorTypesequenceIteratorNewcallableIteratorNew$fConcreteSequenceIterator$fObjectSequenceIterator$fIteratorSequenceIterator$fConcreteCallableIterator$fObjectCallableIterator$fIteratorCallableIteratorMethod methodTypeself$fConcreteMethod$fObjectMethodSlice sliceType getIndices$fConcreteSlice $fObjectSlice tupleTypetoTupleiterableToTuple fromTuplegetSlice$fConcreteTuple FrozenSetSetAnySetsetType frozenSetTypetoSet toFrozenSet iterableToSetiterableToFrozenSetfromSetadddiscardpop $fAnySetSet $fConcreteSet $fObjectSet$fAnySetFrozenSet$fConcreteFrozenSet$fObjectFrozenSetlistTypetoListiterableToListfromListinsertsetSlicesortreverse$fConcreteListtypeType isSubtype$fConcreteType FindDirectionForwards BackwardsMatchDirectionPrefixSuffix ErrorHandlingStrictReplaceIgnoreEncodingUnicode unicodeType toUnicode fromUnicodefromEncodedObjectencodedecodesplit splitLines translatejoin tailMatchfindcountreplaceformat$fConcreteUnicode$fObjectUnicode$fShowFindDirection$fEqFindDirection$fShowMatchDirection$fEqMatchDirection$fShowErrorHandling$fEqErrorHandlingcastToSequencerepeat inPlaceAppend inPlaceRepeat deleteSliceindexfast$fSequenceUnicode$fSequenceTuple$fSequenceList$fSequenceBytes$fSequenceByteArray ComparisonLTLEEQNEGTGEgetType isInstance isSubclasscast hasAttribute getAttribute setAttributedeleteAttributeprintreprasciistringbytescallablecallcallArgs callMethodcallMethodArgs richComparetoBoolhashdir getIterator$fShowComparisonInteger integerType toInteger fromInteger$fConcreteInteger$fObjectIntegerModule moduleType getDictionary getFilename addObjectaddIntegerConstantaddTextConstant importModulereload$fConcreteModule$fObjectModuleNumbertoNumber SomeNumber castToNumbersubtractmultiply floorDivide trueDivide remainderdivmodpowernegativepositiveabsoluteinvertshiftLshiftRandxoror inPlaceAddinPlaceSubtractinPlaceMultiplyinPlaceFloorDivideinPlaceTrueDivideinPlaceRemainder inPlacePower inPlaceShiftL inPlaceShiftR inPlaceAnd inPlaceXor inPlaceOrtoBase$fNumberFrozenSet $fNumberSet$fNumberComplex $fNumberFloat$fNumberInteger$fNumberSomeNumber$fObjectSomeNumberProxy Reference newReferencenewProxy$fObjectReference $fObjectProxyPyCastExceptionFromPyfromPyToPytoPyeasyToPy easyFromPy$fToPy[] $fToPyMaybe $fToPy(,,,) $fToPy(,,) $fToPy(,) $fToPy[]0 $fToPyChar $fToPyText $fToPyDouble $fToPyInteger $fToPyBool $fFromPy() $fFromPy[] $fFromPyMaybe $fFromPy(,,,) $fFromPy(,,) $fFromPy(,) $fFromPy[]0 $fFromPyChar $fFromPyText$fFromPyDouble$fFromPyInteger $fFromPyBool$fExceptionPyCastException$fShowPyCastExceptionarg $fToPyArgghc-prim GHC.TypesIntbaseGHC.WordWord8GHC.ForeignPtr ForeignPtrWordWord64Word32Word16Foreign.StorableStorablepokepeek pokeByteOff peekByteOff pokeElemOff peekElemOffsizeOf alignmentGHC.IntInt8Int16Int32Int64 GHC.Stable StablePtrGHC.PtrPtrFunPtrGHC.Bits FiniteBitscountTrailingZeros finiteBitSizecountLeadingZerosBitspopCountrotateRrotateL unsafeShiftR unsafeShiftLisSignedbitSize bitSizeMaybetestBit complementBitclearBitsetBitbitzeroBitsrotateshift complement.&..|. Data.BitsIffgetIffXorgetXorIorgetIorAndgetAnd Foreign.PtrIntPtrWordPtrFinalizerEnvPtr FinalizerPtrForeign.Marshal.PoolPoolForeign.Marshal.ArraynewArrayfreeHaskellFunPtrnullPtrForeign.Marshal.AllocmallocwithForeignPtr mallocArray mallocArray0Foreign.Marshal.Utilsfree finalizerFreeallocawithtouchForeignPtraddForeignPtrFinalizer newStablePtr bitDefaulttestBitDefaultpopCountDefaulttoIntegralSized byteSwap16 byteSwap32 byteSwap64 bitReverse8 bitReverse16 bitReverse32 bitReverse64castPtrplusPtralignPtrminusPtr nullFunPtr castFunPtrcastFunPtrToPtrcastPtrToFunPtr freeStablePtrdeRefStablePtrcastStablePtrToPtrcastPtrToStablePtroneBits.^..>>..<<.!>>.!<<. ptrToWordPtr wordPtrToPtr ptrToIntPtr intPtrToPtrmallocForeignPtrmallocForeignPtrBytesaddForeignPtrFinalizerEnvcastForeignPtrplusForeignPtrfinalizeForeignPtrForeign.ForeignPtr.ImpnewForeignPtrEnvmallocForeignPtrArraymallocForeignPtrArray0calloc mallocBytes callocBytes allocaBytesallocaBytesAlignedrealloc reallocBytesfromBoolmaybeNew maybeWith maybePeekwithMany copyBytes moveBytes fillBytes callocArray callocArray0 allocaArray allocaArray0 reallocArray reallocArray0 peekArray peekArray0 pokeArray pokeArray0 newArray0 withArray withArrayLen withArray0 withArrayLen0 copyArray moveArray lengthArray0 advancePtrForeign.Marshal.ErrorthrowIfthrowIf_ throwIfNeg throwIfNeg_ throwIfNullvoidnewPoolfreePoolwithPool pooledMallocpooledMallocBytes pooledReallocpooledReallocBytespooledMallocArraypooledMallocArray0pooledReallocArraypooledReallocArray0 pooledNewpooledNewArraypooledNewArray0Foreign.C.StringCStringForeign.C.TypesCUIntMaxCIntMaxCUIntPtrCIntPtrCJmpBufCFposCFile CSUSeconds CUSecondsCTimeCClock CSigAtomicCWcharCSizeCPtrdiffCDoubleCFloatCBoolCULLongCLLongCULongCLongCUIntCIntCUShortCShortCUCharCSCharCChar CWStringLenCWString CStringLenForeign.C.ErrorErrno peekCStringpeekCStringLen newCString newCStringLen withCStringwithCStringLencharIsRepresentablecastCCharToCharcastCharToCCharcastCUCharToCharcastCharToCUCharcastCSCharToCharcastCharToCSChar peekCAStringpeekCAStringLen newCAStringnewCAStringLen withCAStringwithCAStringLen peekCWStringpeekCWStringLen newCWStringnewCWStringLen withCWStringwithCWStringLeneOKe2BIGeACCES eADDRINUSE eADDRNOTAVAILeADV eAFNOSUPPORTeAGAINeALREADYeBADFeBADMSGeBADRPCeBUSYeCHILDeCOMM eCONNABORTED eCONNREFUSED eCONNRESETeDEADLK eDESTADDRREQeDIRTYeDOMeDQUOTeEXISTeFAULTeFBIGeFTYPE eHOSTDOWN eHOSTUNREACHeIDRMeILSEQ eINPROGRESSeINTReINVALeIOeISCONNeISDIReLOOPeMFILEeMLINKeMSGSIZE eMULTIHOP eNAMETOOLONGeNETDOWN eNETRESET eNETUNREACHeNFILEeNOBUFSeNODATAeNODEVeNOENTeNOEXECeNOLCKeNOLINKeNOMEMeNOMSGeNONET eNOPROTOOPTeNOSPCeNOSReNOSTReNOSYSeNOTBLKeNOTCONNeNOTDIR eNOTEMPTYeNOTSOCKeNOTSUPeNOTTYeNXIO eOPNOTSUPPePERM ePFNOSUPPORTePIPEePROCLIM ePROCUNAVAIL ePROGMISMATCH ePROGUNAVAILePROTOePROTONOSUPPORT ePROTOTYPEeRANGEeREMCHGeREMOTEeROFS eRPCMISMATCHeRREMOTE eSHUTDOWNeSOCKTNOSUPPORTeSPIPEeSRCHeSRMNTeSTALEeTIME eTIMEDOUT eTOOMANYREFSeTXTBSYeUSERS eWOULDBLOCKeXDEV isValidErrnogetErrno resetErrno throwErrno throwErrnoIf throwErrnoIf_throwErrnoIfRetrythrowErrnoIfRetryMayBlockthrowErrnoIfRetry_throwErrnoIfRetryMayBlock_throwErrnoIfMinus1throwErrnoIfMinus1_throwErrnoIfMinus1RetrythrowErrnoIfMinus1Retry_throwErrnoIfMinus1RetryMayBlock throwErrnoIfMinus1RetryMayBlock_throwErrnoIfNullthrowErrnoIfNullRetrythrowErrnoIfNullRetryMayBlockthrowErrnoPaththrowErrnoPathIfthrowErrnoPathIf_throwErrnoPathIfNullthrowErrnoPathIfMinus1throwErrnoPathIfMinus1_errnoToIOErrorcToBool cFromBoolpeekText peekTextWpeekMaybeTextWwithText withTextWwithMaybeTextWmapWith GHC.IO.UnsafeunsafePerformIOfromForeignPtr concreteType withObject peekObjectpeekStaticObject stealObjectincrefdecref callObjectRaw unsafeCast exceptionIfcheckStatusCodecheckBoolReturncheckIntReturnunsafeCastToMappingunsafeCastToSequenceunsafeCastToIteratorTrueFalse GHC.MaybeNothingGHC.BaseString Data.TypeabletypeRep ghc-bignumGHC.Num.Integer Data.ProxyArgDouble