neulab/docprompting-conala huggingface dataset:
st_reparse_tag  
When st_file_attributes has the FILE_ATTRIBUTE_REPARSE_POINT set, this field contains the tag identifying the type of reparse point. See the IO_REPARSE_TAG_* constants in the stat module.
st_size  
Size of the file in bytes, if it is a regular file or a symbolic link. The size of a symbolic link is the length of the pathname it contains, without a terminating null byte.
os.strerror(code)  
Return the error message corresponding to the error code in code. On platforms where strerror() returns NULL when given an unknown error number, ValueError is raised.
os.supports_bytes_environ  
True if the native OS type of the environment is bytes (eg. False on Windows).  New in version 3.2.
os.supports_dir_fd  
A set object indicating which functions in the os module accept an open file descriptor for their dir_fd parameter. Different platforms provide different features, and the underlying functionality Python uses to implement the dir_fd parameter is not available on all platforms Python supports. For consistency’s sake, functions that may support dir_fd always allow specifying the parameter, but will throw an exception if the functionality is used when it’s not locally available. (Specifying None for dir_fd is always supported on all platforms.) To check whether a particular function accepts an open file descriptor for its dir_fd parameter, use the in operator on supports_dir_fd. As an example, this expression evaluates to True if os.stat() accepts open file descriptors for dir_fd on the local platform: os.stat in os.supports_dir_fd
 Currently dir_fd parameters only work on Unix platforms; none of them work on Windows.  New in version 3.3.
os.supports_effective_ids  
A set object indicating whether os.access() permits specifying True for its effective_ids parameter on the local platform. (Specifying False for effective_ids is always supported on all platforms.) If the local platform supports it, the collection will contain os.access(); otherwise it will be empty. This expression evaluates to True if os.access() supports effective_ids=True on the local platform: os.access in os.supports_effective_ids
 Currently effective_ids is only supported on Unix platforms; it does not work on Windows.  New in version 3.3.
os.supports_fd  
A set object indicating which functions in the os module permit specifying their path parameter as an open file descriptor on the local platform. Different platforms provide different features, and the underlying functionality Python uses to accept open file descriptors as path arguments is not available on all platforms Python supports. To determine whether a particular function permits specifying an open file descriptor for its path parameter, use the in operator on supports_fd. As an example, this expression evaluates to True if os.chdir() accepts open file descriptors for path on your local platform: os.chdir in os.supports_fd
  New in version 3.3.
os.supports_follow_symlinks  
A set object indicating which functions in the os module accept False for their follow_symlinks parameter on the local platform. Different platforms provide different features, and the underlying functionality Python uses to implement follow_symlinks is not available on all platforms Python supports. For consistency’s sake, functions that may support follow_symlinks always allow specifying the parameter, but will throw an exception if the functionality is used when it’s not locally available. (Specifying True for follow_symlinks is always supported on all platforms.) To check whether a particular function accepts False for its follow_symlinks parameter, use the in operator on supports_follow_symlinks. As an example, this expression evaluates to True if you may specify follow_symlinks=False when calling os.stat() on the local platform: os.stat in os.supports_follow_symlinks
  New in version 3.3.
os.symlink(src, dst, target_is_directory=False, *, dir_fd=None)  
Create a symbolic link pointing to src named dst. On Windows, a symlink represents either a file or a directory, and does not morph to the target dynamically. If the target is present, the type of the symlink will be created to match. Otherwise, the symlink will be created as a directory if target_is_directory is True or a file symlink (the default) otherwise. On non-Windows platforms, target_is_directory is ignored. This function can support paths relative to directory descriptors.  Note On newer versions of Windows 10, unprivileged accounts can create symlinks if Developer Mode is enabled. When Developer Mode is not available/enabled, the SeCreateSymbolicLinkPrivilege privilege is required, or the process must be run as an administrator. OSError is raised when the function is called by an unprivileged user.  Raises an auditing event os.symlink with arguments src, dst, dir_fd. Availability: Unix, Windows.  Changed in version 3.2: Added support for Windows 6.0 (Vista) symbolic links.   New in version 3.3: Added the dir_fd argument, and now allow target_is_directory on non-Windows platforms.   Changed in version 3.6: Accepts a path-like object for src and dst.   Changed in version 3.8: Added support for unelevated symlinks on Windows with Developer Mode.
os.sync()  
Force write of everything to disk. Availability: Unix.  New in version 3.3.
os.sysconf(name)  
Return integer-valued system configuration values. If the configuration value specified by name isn’t defined, -1 is returned. The comments regarding the name parameter for confstr() apply here as well; the dictionary that provides information on the known names is given by sysconf_names. Availability: Unix.
os.sysconf_names  
Dictionary mapping names accepted by sysconf() to the integer values defined for those names by the host operating system. This can be used to determine the set of names known to the system. Availability: Unix.
os.system(command)  
Execute the command (a string) in a subshell. This is implemented by calling the Standard C function system(), and has the same limitations. Changes to sys.stdin, etc. are not reflected in the environment of the executed command. If command generates any output, it will be sent to the interpreter standard output stream. On Unix, the return value is the exit status of the process encoded in the format specified for wait(). Note that POSIX does not specify the meaning of the return value of the C system() function, so the return value of the Python function is system-dependent. On Windows, the return value is that returned by the system shell after running command. The shell is given by the Windows environment variable COMSPEC: it is usually cmd.exe, which returns the exit status of the command run; on systems using a non-native shell, consult your shell documentation. The subprocess module provides more powerful facilities for spawning new processes and retrieving their results; using that module is preferable to using this function. See the Replacing Older Functions with the subprocess Module section in the subprocess documentation for some helpful recipes. On Unix, waitstatus_to_exitcode() can be used to convert the result (exit status) into an exit code. On Windows, the result is directly the exit code. Raises an auditing event os.system with argument command. Availability: Unix, Windows.
os.tcgetpgrp(fd)  
Return the process group associated with the terminal given by fd (an open file descriptor as returned by os.open()). Availability: Unix.
os.tcsetpgrp(fd, pg)  
Set the process group associated with the terminal given by fd (an open file descriptor as returned by os.open()) to pg. Availability: Unix.
class os.terminal_size  
A subclass of tuple, holding (columns, lines) of the terminal window size.  
columns  
Width of the terminal window in characters. 
  
lines  
Height of the terminal window in characters.
os.times()  
Returns the current global process times. The return value is an object with five attributes:  
user - user time 
system - system time 
children_user - user time of all child processes 
children_system - system time of all child processes 
elapsed - elapsed real time since a fixed point in the past  For backwards compatibility, this object also behaves like a five-tuple containing user, system, children_user, children_system, and elapsed in that order. See the Unix manual page times(2) and times(3) manual page on Unix or the GetProcessTimes MSDN on Windows. On Windows, only user and system are known; the other attributes are zero. Availability: Unix, Windows.  Changed in version 3.3: Return type changed from a tuple to a tuple-like object with named attributes.
os.truncate(path, length)  
Truncate the file corresponding to path, so that it is at most length bytes in size. This function can support specifying a file descriptor. Raises an auditing event os.truncate with arguments path, length. Availability: Unix, Windows.  New in version 3.3.   Changed in version 3.5: Added support for Windows   Changed in version 3.6: Accepts a path-like object.
os.ttyname(fd)  
Return a string which specifies the terminal device associated with file descriptor fd. If fd is not associated with a terminal device, an exception is raised. Availability: Unix.
os.umask(mask)  
Set the current numeric umask and return the previous umask.
os.uname()  
Returns information identifying the current operating system. The return value is an object with five attributes:  
sysname - operating system name 
nodename - name of machine on network (implementation-defined) 
release - operating system release 
version - operating system version 
machine - hardware identifier  For backwards compatibility, this object is also iterable, behaving like a five-tuple containing sysname, nodename, release, version, and machine in that order. Some systems truncate nodename to 8 characters or to the leading component; a better way to get the hostname is socket.gethostname() or even socket.gethostbyaddr(socket.gethostname()). Availability: recent flavors of Unix.  Changed in version 3.3: Return type changed from a tuple to a tuple-like object with named attributes.
os.unlink(path, *, dir_fd=None)  
Remove (delete) the file path. This function is semantically identical to remove(); the unlink name is its traditional Unix name. Please see the documentation for remove() for further information. Raises an auditing event os.remove with arguments path, dir_fd.  New in version 3.3: The dir_fd parameter.   Changed in version 3.6: Accepts a path-like object.
os.unsetenv(key)  
Unset (delete) the environment variable named key. Such changes to the environment affect subprocesses started with os.system(), popen() or fork() and execv(). Deletion of items in os.environ is automatically translated into a corresponding call to unsetenv(); however, calls to unsetenv() don’t update os.environ, so it is actually preferable to delete items of os.environ. Raises an auditing event os.unsetenv with argument key.  Changed in version 3.9: The function is now always available and is also available on Windows.
os.urandom(size)  
Return a string of size random bytes suitable for cryptographic use. This function returns random bytes from an OS-specific randomness source. The returned data should be unpredictable enough for cryptographic applications, though its exact quality depends on the OS implementation. On Linux, if the getrandom() syscall is available, it is used in blocking mode: block until the system urandom entropy pool is initialized (128 bits of entropy are collected by the kernel). See the PEP 524 for the rationale. On Linux, the getrandom() function can be used to get random bytes in non-blocking mode (using the GRND_NONBLOCK flag) or to poll until the system urandom entropy pool is initialized. On a Unix-like system, random bytes are read from the /dev/urandom device. If the /dev/urandom device is not available or not readable, the NotImplementedError exception is raised. On Windows, it will use CryptGenRandom().  See also The secrets module provides higher level functions. For an easy-to-use interface to the random number generator provided by your platform, please see random.SystemRandom.   Changed in version 3.6.0: On Linux, getrandom() is now used in blocking mode to increase the security.   Changed in version 3.5.2: On Linux, if the getrandom() syscall blocks (the urandom entropy pool is not initialized yet), fall back on reading /dev/urandom.   Changed in version 3.5: On Linux 3.17 and newer, the getrandom() syscall is now used when available. On OpenBSD 5.6 and newer, the C getentropy() function is now used. These functions avoid the usage of an internal file descriptor.
os.utime(path, times=None, *, [ns, ]dir_fd=None, follow_symlinks=True)  
Set the access and modified times of the file specified by path. utime() takes two optional parameters, times and ns. These specify the times set on path and are used as follows:  If ns is specified, it must be a 2-tuple of the form (atime_ns, mtime_ns) where each member is an int expressing nanoseconds. If times is not None, it must be a 2-tuple of the form (atime, mtime) where each member is an int or float expressing seconds. If times is None and ns is unspecified, this is equivalent to specifying ns=(atime_ns, mtime_ns) where both times are the current time.  It is an error to specify tuples for both times and ns. Note that the exact times you set here may not be returned by a subsequent stat() call, depending on the resolution with which your operating system records access and modification times; see stat(). The best way to preserve exact times is to use the st_atime_ns and st_mtime_ns fields from the os.stat() result object with the ns parameter to utime. This function can support specifying a file descriptor, paths relative to directory descriptors and not following symlinks. Raises an auditing event os.utime with arguments path, times, ns, dir_fd.  New in version 3.3: Added support for specifying path as an open file descriptor, and the dir_fd, follow_symlinks, and ns parameters.   Changed in version 3.6: Accepts a path-like object.
os.wait()  
Wait for completion of a child process, and return a tuple containing its pid and exit status indication: a 16-bit number, whose low byte is the signal number that killed the process, and whose high byte is the exit status (if the signal number is zero); the high bit of the low byte is set if a core file was produced. waitstatus_to_exitcode() can be used to convert the exit status into an exit code. Availability: Unix.  See also waitpid() can be used to wait for the completion of a specific child process and has more options.
os.wait3(options)  
Similar to waitpid(), except no process id argument is given and a 3-element tuple containing the child’s process id, exit status indication, and resource usage information is returned. Refer to resource.getrusage() for details on resource usage information. The option argument is the same as that provided to waitpid() and wait4(). waitstatus_to_exitcode() can be used to convert the exit status into an exitcode. Availability: Unix.
os.wait4(pid, options)  
Similar to waitpid(), except a 3-element tuple, containing the child’s process id, exit status indication, and resource usage information is returned. Refer to resource.getrusage() for details on resource usage information. The arguments to wait4() are the same as those provided to waitpid(). waitstatus_to_exitcode() can be used to convert the exit status into an exitcode. Availability: Unix.
os.waitid(idtype, id, options)  
Wait for the completion of one or more child processes. idtype can be P_PID, P_PGID, P_ALL, or P_PIDFD on Linux. id specifies the pid to wait on. options is constructed from the ORing of one or more of WEXITED, WSTOPPED or WCONTINUED and additionally may be ORed with WNOHANG or WNOWAIT. The return value is an object representing the data contained in the siginfo_t structure, namely: si_pid, si_uid, si_signo, si_status, si_code or None if WNOHANG is specified and there are no children in a waitable state. Availability: Unix.  New in version 3.3.
os.waitpid(pid, options)  
The details of this function differ on Unix and Windows. On Unix: Wait for completion of a child process given by process id pid, and return a tuple containing its process id and exit status indication (encoded as for wait()). The semantics of the call are affected by the value of the integer options, which should be 0 for normal operation. If pid is greater than 0, waitpid() requests status information for that specific process. If pid is 0, the request is for the status of any child in the process group of the current process. If pid is -1, the request pertains to any child of the current process. If pid is less than -1, status is requested for any process in the process group -pid (the absolute value of pid). An OSError is raised with the value of errno when the syscall returns -1. On Windows: Wait for completion of a process given by process handle pid, and return a tuple containing pid, and its exit status shifted left by 8 bits (shifting makes cross-platform use of the function easier). A pid less than or equal to 0 has no special meaning on Windows, and raises an exception. The value of integer options has no effect. pid can refer to any process whose id is known, not necessarily a child process. The spawn* functions called with P_NOWAIT return suitable process handles. waitstatus_to_exitcode() can be used to convert the exit status into an exit code.  Changed in version 3.5: If the system call is interrupted and the signal handler does not raise an exception, the function now retries the system call instead of raising an InterruptedError exception (see PEP 475 for the rationale).
os.waitstatus_to_exitcode(status)  
Convert a wait status to an exit code. On Unix:  If the process exited normally (if WIFEXITED(status) is true), return the process exit status (return WEXITSTATUS(status)): result greater than or equal to 0. If the process was terminated by a signal (if WIFSIGNALED(status) is true), return -signum where signum is the number of the signal that caused the process to terminate (return -WTERMSIG(status)): result less than 0. Otherwise, raise a ValueError.  On Windows, return status shifted right by 8 bits. On Unix, if the process is being traced or if waitpid() was called with WUNTRACED option, the caller must first check if WIFSTOPPED(status) is true. This function must not be called if WIFSTOPPED(status) is true.  See also WIFEXITED(), WEXITSTATUS(), WIFSIGNALED(), WTERMSIG(), WIFSTOPPED(), WSTOPSIG() functions.   New in version 3.9.
os.WCONTINUED  
This option causes child processes to be reported if they have been continued from a job control stop since their status was last reported. Availability: some Unix systems.
os.WCOREDUMP(status)  
Return True if a core dump was generated for the process, otherwise return False. This function should be employed only if WIFSIGNALED() is true. Availability: Unix.
os.WEXITED  
os.WSTOPPED  
os.WNOWAIT  
Flags that can be used in options in waitid() that specify what child signal to wait for. Availability: Unix.  New in version 3.3.
os.WEXITSTATUS(status)  
Return the process exit status. This function should be employed only if WIFEXITED() is true. Availability: Unix.
os.WIFCONTINUED(status)  
Return True if a stopped child has been resumed by delivery of SIGCONT (if the process has been continued from a job control stop), otherwise return False. See WCONTINUED option. Availability: Unix.
os.WIFEXITED(status)  
Return True if the process exited terminated normally, that is, by calling exit() or _exit(), or by returning from main(); otherwise return False. Availability: Unix.
os.WIFSIGNALED(status)  
Return True if the process was terminated by a signal, otherwise return False. Availability: Unix.
os.WIFSTOPPED(status)  
Return True if the process was stopped by delivery of a signal, otherwise return False. WIFSTOPPED() only returns True if the waitpid() call was done using WUNTRACED option or when the process is being traced (see ptrace(2)). Availability: Unix.
os.WNOHANG  
The option for waitpid() to return immediately if no child process status is available immediately. The function returns (0, 0) in this case. Availability: Unix.
os.write(fd, str)  
Write the bytestring in str to file descriptor fd. Return the number of bytes actually written.  Note This function is intended for low-level I/O and must be applied to a file descriptor as returned by os.open() or pipe(). To write a “file object” returned by the built-in function open() or by popen() or fdopen(), or sys.stdout or sys.stderr, use its write() method.   Changed in version 3.5: If the system call is interrupted and the signal handler does not raise an exception, the function now retries the system call instead of raising an InterruptedError exception (see PEP 475 for the rationale).
os.writev(fd, buffers)  
Write the contents of buffers to file descriptor fd. buffers must be a sequence of bytes-like objects. Buffers are processed in array order. Entire contents of the first buffer is written before proceeding to the second, and so on. Returns the total number of bytes actually written. The operating system may set a limit (sysconf() value 'SC_IOV_MAX') on the number of buffers that can be used. Availability: Unix.  New in version 3.3.
os.WSTOPSIG(status)  
Return the signal which caused the process to stop. This function should be employed only if WIFSTOPPED() is true. Availability: Unix.
os.WTERMSIG(status)  
Return the number of the signal that caused the process to terminate. This function should be employed only if WIFSIGNALED() is true. Availability: Unix.
os.WUNTRACED  
This option causes child processes to be reported if they have been stopped but their current state has not been reported since they were stopped. Availability: Unix.
os.XATTR_CREATE  
This is a possible value for the flags argument in setxattr(). It indicates the operation must create an attribute.
os.XATTR_REPLACE  
This is a possible value for the flags argument in setxattr(). It indicates the operation must replace an existing attribute.
os.XATTR_SIZE_MAX  
The maximum size the value of an extended attribute can be. Currently, this is 64 KiB on Linux.
os._exit(n)  
Exit the process with status n, without calling cleanup handlers, flushing stdio buffers, etc.  Note The standard way to exit is sys.exit(n). _exit() should normally only be used in the child process after a fork().