cafe-grader-web

Location: cafe-grader-web/lib/assets/Lib/posix.py - annotation

Show More
Commit Description:
Merge pull request #17 from nattee/master...
Commit Description:
Merge pull request #17 from nattee/master upgrade to current working snapshot
References:
r715:88baf2c40c51 merge default
File last commit:
r584:056392c00e67 merge java
Show/Diff file:
Action:
lib/assets/Lib/posix.py | 641 lines | 22.1 KiB | text/x-python | PythonLexer |
History | Source | Raw | Download
admin
merge with algo and add brython files that were missing
 r584 """This module provides access to operating system functionality that is
standardized by the C Standard and the POSIX standard (a thinly
disguised Unix interface). Refer to the library manual and
corresponding Unix manual entries for more information on calls."""
import datetime
from browser import window
def _randint(a, b):
return int(window.Math.random()*(b-a+1)+a)
F_OK = 0
O_APPEND = 8
O_BINARY = 32768
O_CREAT = 256
O_EXCL = 1024
O_NOINHERIT = 128
O_RANDOM = 16
O_RDONLY = 0
O_RDWR = 2
O_SEQUENTIAL = 32
O_SHORT_LIVED = 4096
O_TEMPORARY = 64
O_TEXT = 16384
O_TRUNC = 512
O_WRONLY = 1
P_DETACH = 4
P_NOWAIT = 1
P_NOWAITO = 3
P_OVERLAY = 2
P_WAIT = 0
R_OK = 4
TMP_MAX = 32767
W_OK = 2
X_OK = 1
class __loader__:
pass
def _exit(*args,**kw):
"""_exit(status)
Exit to the system with specified status, without normal exit processing."""
pass
def _getdiskusage(*args,**kw):
"""_getdiskusage(path) -> (total, free)
Return disk usage statistics about the given path as (total, free) tuple."""
pass
def _getfileinformation(*args,**kw):
pass
def _getfinalpathname(*args,**kw):
pass
def _getfullpathname(*args,**kw):
pass
_have_functions = ['MS_WINDOWS']
def _isdir(*args,**kw):
"""Return true if the pathname refers to an existing directory."""
pass
def abort(*args,**kw):
"""abort() -> does not return!
Abort the interpreter immediately. This 'dumps core' or otherwise fails
in the hardest way possible on the hosting operating system."""
pass
def access(*args,**kw):
"""access(path, mode, *, dir_fd=None, effective_ids=False, follow_symlinks=True)
Use the real uid/gid to test for access to a path. Returns True if granted,
False otherwise.
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
If effective_ids is True, access will use the effective uid/gid instead of
the real uid/gid.
If follow_symlinks is False, and the last element of the path is a symbolic
link, access will examine the symbolic link itself instead of the file the
link points to.
dir_fd, effective_ids, and follow_symlinks may not be implemented
on your platform. If they are unavailable, using them will raise a
NotImplementedError.
Note that most operations will use the effective uid/gid, therefore this
routine can be used in a suid/sgid environment to test if the invoking user
has the specified access to the path.
The mode argument can be F_OK to test existence, or the inclusive-OR
of R_OK, W_OK, and X_OK."""
pass
def chdir(*args,**kw):
"""chdir(path)
Change the current working directory to the specified path.
path may always be specified as a string.
On some platforms, path may also be specified as an open file descriptor.
If this functionality is unavailable, using it raises an exception."""
pass
def chmod(*args,**kw):
"""chmod(path, mode, *, dir_fd=None, follow_symlinks=True)
Change the access permissions of a file.
path may always be specified as a string.
On some platforms, path may also be specified as an open file descriptor.
If this functionality is unavailable, using it raises an exception.
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
If follow_symlinks is False, and the last element of the path is a symbolic
link, chmod will modify the symbolic link itself instead of the file the
link points to.
It is an error to use dir_fd or follow_symlinks when specifying path as
an open file descriptor.
dir_fd and follow_symlinks may not be implemented on your platform.
If they are unavailable, using them will raise a NotImplementedError."""
pass
def close(*args,**kw):
"""close(fd)
Close a file descriptor (for low level IO)."""
pass
def closerange(*args,**kw):
"""closerange(fd_low, fd_high)
Closes all file descriptors in [fd_low, fd_high), ignoring errors."""
pass
def device_encoding(*args,**kw):
"""device_encoding(fd) -> str
Return a string describing the encoding of the device
if the output is a terminal; else return None."""
pass
def dup(*args,**kw):
"""dup(fd) -> fd2
Return a duplicate of a file descriptor."""
pass
def dup2(*args,**kw):
"""dup2(old_fd, new_fd)
Duplicate file descriptor."""
pass
environ = {'PYTHONUSERBASE': ' '}
error = OSError
def execv(*args,**kw):
"""execv(path, args)
Execute an executable path with arguments, replacing current process.
path: path of executable file
args: tuple or list of strings"""
pass
def execve(*args,**kw):
"""execve(path, args, env)
Execute a path with arguments and environment, replacing current process.
path: path of executable file
args: tuple or list of arguments
env: dictionary of strings mapping to strings
On some platforms, you may specify an open file descriptor for path;
execve will execute the program the file descriptor is open to.
If this functionality is unavailable, using it raises NotImplementedError."""
pass
def fstat(*args,**kw):
"""fstat(fd) -> stat result
Like stat(), but for an open file descriptor.
Equivalent to stat(fd=fd)."""
pass
def fsync(*args,**kw):
"""fsync(fildes)
force write of file with filedescriptor to disk."""
pass
def get_terminal_size(*args,**kw):
"""Return the size of the terminal window as (columns, lines).
The optional argument fd (default standard output) specifies
which file descriptor should be queried.
If the file descriptor is not connected to a terminal, an OSError
is thrown.
This function will only be defined if an implementation is
available for this system.
shutil.get_terminal_size is the high-level function which should
normally be used, os.get_terminal_size is the low-level implementation."""
pass
def getcwd(*args,**kw):
"""getcwd() -> path
Return a unicode string representing the current working directory."""
return __BRYTHON__.brython_path # XXX fix me
def getcwdb(*args,**kw):
"""getcwdb() -> path
Return a bytes string representing the current working directory."""
pass
def getlogin(*args,**kw):
"""getlogin() -> string
Return the actual login name."""
pass
def getpid(*args,**kw):
"""getpid() -> pid
Return the current process id"""
return 0
def getppid(*args,**kw):
"""getppid() -> ppid
Return the parent's process id. If the parent process has already exited,
Windows machines will still return its id; others systems will return the id
of the 'init' process (1)."""
pass
def isatty(*args,**kw):
"""isatty(fd) -> bool
Return True if the file descriptor 'fd' is an open file descriptor
connected to the slave end of a terminal."""
pass
def kill(*args,**kw):
"""kill(pid, sig)
Kill a process with a signal."""
pass
def link(*args,**kw):
"""link(src, dst, *, src_dir_fd=None, dst_dir_fd=None, follow_symlinks=True)
Create a hard link to a file.
If either src_dir_fd or dst_dir_fd is not None, it should be a file
descriptor open to a directory, and the respective path string (src or dst)
should be relative; the path will then be relative to that directory.
If follow_symlinks is False, and the last element of src is a symbolic
link, link will create a link to the symbolic link itself instead of the
file the link points to.
src_dir_fd, dst_dir_fd, and follow_symlinks may not be implemented on your
platform. If they are unavailable, using them will raise a
NotImplementedError."""
pass
def listdir(*args,**kw):
"""listdir(path='.') -> list_of_filenames
Return a list containing the names of the files in the directory.
The list is in arbitrary order. It does not include the special
entries '.' and '..' even if they are present in the directory.
path can be specified as either str or bytes. If path is bytes,
the filenames returned will also be bytes; in all other circumstances
the filenames returned will be str.
On some platforms, path may also be specified as an open file descriptor;
the file descriptor must refer to a directory.
If this functionality is unavailable, using it raises NotImplementedError."""
pass
def lseek(*args,**kw):
"""lseek(fd, pos, how) -> newpos
Set the current position of a file descriptor.
Return the new cursor position in bytes, starting from the beginning."""
pass
def lstat(*args,**kw):
"""lstat(path, *, dir_fd=None) -> stat result
Like stat(), but do not follow symbolic links.
Equivalent to stat(path, follow_symlinks=False)."""
return stat_result()
def mkdir(*args,**kw):
"""mkdir(path, mode=0o777, *, dir_fd=None)
Create a directory.
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError.
The mode argument is ignored on Windows."""
pass
def open(path, flags, mode=0o777, *args, dir_fd=None):
"""open(path, flags, mode=0o777, *, dir_fd=None)
Open a file for low level IO. Returns a file handle (integer).
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError."""
## lets assume this is reading/writing to a local storage in the browser
from browser.local_storage import storage
class mystorage:
def __init__(self, path, flags):
self._path=path
self._pos=0
self._flags=flags
if self._flags & O_RDONLY == O_RDONLY:
self._data=storage.get(self._path, None)
if self._data is None:
raise FileNotFoundError("%s not found" % self._path)
elif self._flags & O_WRONLY == O_WRONLY:
storage[self._path]=''
def seek(self, pos):
self._pos=pos
def read(self, size=None):
if size is None:
_result=self._data[self._pos:]
self._pos=len(self._data)
return _result
assert size <= len(self._data) - self._pos
_result=self._data[self._pos: self._pos+size]
self._pos+=size
return _result
def write(self, data):
storage[self._path]+=str(data)
def close(self):
pass
return mystorage(path, flags)
def pipe(*args,**kw):
"""pipe() -> (read_end, write_end)
Create a pipe."""
pass
def putenv(*args,**kw):
"""putenv(key, value)
Change or add an environment variable."""
pass
def read(*args,**kw):
"""read(fd, buffersize) -> string
Read a file descriptor."""
pass
def readlink(*args,**kw):
"""readlink(path, *, dir_fd=None) -> path
Return a string representing the path to which the symbolic link points.
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError."""
pass
def remove(*args,**kw):
"""remove(path, *, dir_fd=None)
Remove a file (same as unlink()).
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError."""
pass
def rename(*args,**kw):
"""rename(src, dst, *, src_dir_fd=None, dst_dir_fd=None)
Rename a file or directory.
If either src_dir_fd or dst_dir_fd is not None, it should be a file
descriptor open to a directory, and the respective path string (src or dst)
should be relative; the path will then be relative to that directory.
src_dir_fd and dst_dir_fd, may not be implemented on your platform.
If they are unavailable, using them will raise a NotImplementedError."""
pass
def replace(*args,**kw):
"""replace(src, dst, *, src_dir_fd=None, dst_dir_fd=None)
Rename a file or directory, overwriting the destination.
If either src_dir_fd or dst_dir_fd is not None, it should be a file
descriptor open to a directory, and the respective path string (src or dst)
should be relative; the path will then be relative to that directory.
src_dir_fd and dst_dir_fd, may not be implemented on your platform.
If they are unavailable, using them will raise a NotImplementedError."""
pass
def rmdir(*args,**kw):
"""rmdir(path, *, dir_fd=None)
Remove a directory.
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError."""
pass
def spawnv(*args,**kw):
"""spawnv(mode, path, args)
Execute the program 'path' in a new process.
mode: mode of process creation
path: path of executable file
args: tuple or list of strings"""
pass
def spawnve(*args,**kw):
"""spawnve(mode, path, args, env)
Execute the program 'path' in a new process.
mode: mode of process creation
path: path of executable file
args: tuple or list of arguments
env: dictionary of strings mapping to strings"""
pass
def startfile(*args,**kw):
"""startfile(filepath [, operation]) - Start a file with its associated application.
When "operation" is not specified or "open", this acts like
double-clicking the file in Explorer, or giving the file name as an
argument to the DOS "start" command: the file is opened with whatever
application (if any) its extension is associated.
When another "operation" is given, it specifies what should be done with
the file. A typical operation is "print".
startfile returns as soon as the associated application is launched.
There is no option to wait for the application to close, and no way
to retrieve the application's exit status.
The filepath is relative to the current directory. If you want to use
an absolute path, make sure the first character is not a slash ("/");
the underlying Win32 ShellExecute function doesn't work if it is."""
pass
def stat(*args,**kw):
"""stat(path, *, dir_fd=None, follow_symlinks=True) -> stat result
Perform a stat system call on the given path.
path may be specified as either a string or as an open file descriptor.
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be supported on your platform; if it is unavailable, using
it will raise a NotImplementedError.
If follow_symlinks is False, and the last element of the path is a symbolic
link, stat will examine the symbolic link itself instead of the file the
link points to.
It is an error to use dir_fd or follow_symlinks when specifying path as
an open file descriptor."""
return stat_result()
def stat_float_times(*args,**kw):
"""stat_float_times([newval]) -> oldval
Determine whether os.[lf]stat represents time stamps as float objects.
If newval is True, future calls to stat() return floats, if it is False,
future calls return ints.
If newval is omitted, return the current setting.
"""
pass
class stat_result:
def __init__(self):
"""st_mode - protection bits,
st_ino - inode number,
st_dev - device,
st_nlink - number of hard links,
st_uid - user id of owner,
st_gid - group id of owner,
st_size - size of file, in bytes,
st_atime - time of most recent access expressed in seconds,
st_mtime - time of most recent content modification expressed in
seconds,
st_ctime - platform dependent; time of most recent metadata change on
Unix, or the time of creation on Windows, expressed in seconds
st_atime_ns - time of most recent access expressed in nanoseconds as an
integer,
st_mtime_ns - time of most recent content modification expressed in
nanoseconds as an integer,
st_ctime_ns - platform dependent; time of most recent metadata change
on Unix, or the time of creation on Windows, expressed in
nanoseconds as an integer """
# Brython : fake values
self.st_atime = datetime.datetime.now()
self.st_mtime = self.st_ctime = self.st_atime_ns = \
self.st_mtime_ns = self.st_ctime_ns = self.st_atime
self.st_uid = self.st_gid = self.st_ino = -1
self.st_mode = 0
self.st_size = 1
class statvfs_result:
pass
def strerror(*args,**kw):
"""strerror(code) -> string
Translate an error code to a message string."""
pass
def symlink(*args,**kw):
"""symlink(src, dst, target_is_directory=False, *, dir_fd=None)
Create a symbolic link pointing to src named dst.
target_is_directory is required on Windows if the target is to be
interpreted as a directory. (On Windows, symlink requires
Windows 6.0 or greater, and raises a NotImplementedError otherwise.)
target_is_directory is ignored on non-Windows platforms.
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError."""
pass
def system(*args,**kw):
"""system(command) -> exit_status
Execute the command (a string) in a subshell."""
pass
class terminal_size:
pass
def times(*args,**kw):
"""times() -> times_result
Return an object containing floating point numbers indicating process
times. The object behaves like a named tuple with these fields:
(utime, stime, cutime, cstime, elapsed_time)"""
pass
class times_result:
pass
def umask(*args,**kw):
"""umask(new_mask) -> old_mask
Set the current numeric umask and return the previous umask."""
pass
class uname_result:
pass
def unlink(path, *args, dir_fd=None):
"""unlink(path, *, dir_fd=None)
Remove a file (same as remove()).
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
dir_fd may not be implemented on your platform.
If it is unavailable, using it will raise a NotImplementedError."""
pass
def urandom(n):
"""urandom(n) -> str
Return n random bytes suitable for cryptographic use."""
randbytes= [_randint(0,255) for i in range(n)]
return bytes(randbytes)
def utime(*args,**kw):
"""utime(path, times=None, *, ns=None, dir_fd=None, follow_symlinks=True) Set the access and modified time of path.
path may always be specified as a string.
On some platforms, path may also be specified as an open file descriptor.
If this functionality is unavailable, using it raises an exception.
If times is not None, it must be a tuple (atime, mtime);
atime and mtime should be expressed as float seconds since the epoch.
If ns is not None, it must be a tuple (atime_ns, mtime_ns);
atime_ns and mtime_ns should be expressed as integer nanoseconds
since the epoch.
If both times and ns are None, utime uses the current time.
Specifying tuples for both times and ns is an error.
If dir_fd is not None, it should be a file descriptor open to a directory,
and path should be relative; path will then be relative to that directory.
If follow_symlinks is False, and the last element of the path is a symbolic
link, utime will modify the symbolic link itself instead of the file the
link points to.
It is an error to use dir_fd or follow_symlinks when specifying path
as an open file descriptor.
dir_fd and follow_symlinks may not be available on your platform.
If they are unavailable, using them will raise a NotImplementedError."""
pass
def waitpid(*args,**kw):
"""waitpid(pid, options) -> (pid, status << 8)
Wait for completion of a given process. options is ignored on Windows."""
pass
def write(*args,**kw):
"""write(fd, string) -> byteswritten
Write a string to a file descriptor."""
pass
## put WIFSIGNALED here. its needed by os module, and os module imports all
## functions in this module
def WIFSIGNALED(a):
return False
def WTERMSIG(status):
return 0
def WIFSIGNALED(status):
"Return True if the process exited due to a signal, otherwise return False"
return False
def WIFEXITED(status):
return False
def WEXITSTATUS(status):
pass
def WNOHANG():
return (0,0)