feat(assessment): auto comprehensive assessment - rules engine from college scoring standard, per-semester stats, manual overrides, word export
This commit is contained in:
root
@@ -0,0 +1,450 @@
|
||||
"""Utilities to get a password and/or the current user name.
|
||||
|
||||
getpass(prompt[, stream[, echo_char]]) - Prompt for a password, with echo
|
||||
turned off and optional keyboard feedback.
|
||||
getuser() - Get the user name from the environment or password database.
|
||||
|
||||
GetPassWarning - This UserWarning is issued when getpass() cannot prevent
|
||||
echoing of the password contents while reading.
|
||||
|
||||
On Windows, the msvcrt module will be used.
|
||||
|
||||
"""
|
||||
|
||||
# Authors: Piers Lauder (original)
|
||||
# Guido van Rossum (Windows support and cleanup)
|
||||
# Gregory P. Smith (tty support & GetPassWarning)
|
||||
|
||||
import contextlib
|
||||
import io
|
||||
import os
|
||||
import sys
|
||||
|
||||
__all__ = ["getpass","getuser","GetPassWarning"]
|
||||
|
||||
|
||||
class GetPassWarning(UserWarning): pass
|
||||
|
||||
|
||||
# Default POSIX control character mappings
|
||||
_POSIX_CTRL_CHARS = frozendict({
|
||||
'BS': '\x08', # Backspace
|
||||
'ERASE': '\x7f', # DEL
|
||||
'KILL': '\x15', # Ctrl+U - kill line
|
||||
'WERASE': '\x17', # Ctrl+W - erase word
|
||||
'LNEXT': '\x16', # Ctrl+V - literal next
|
||||
'EOF': '\x04', # Ctrl+D - EOF
|
||||
'INTR': '\x03', # Ctrl+C - interrupt
|
||||
'SOH': '\x01', # Ctrl+A - start of heading (beginning of line)
|
||||
'ENQ': '\x05', # Ctrl+E - enquiry (end of line)
|
||||
'VT': '\x0b', # Ctrl+K - vertical tab (kill forward)
|
||||
})
|
||||
|
||||
|
||||
def _get_terminal_ctrl_chars(fd):
|
||||
"""Extract control characters from terminal settings.
|
||||
|
||||
Returns a dict mapping control char names to their str values.
|
||||
|
||||
Falls back to POSIX defaults if termios is not available
|
||||
or if the control character is not supported by termios.
|
||||
"""
|
||||
ctrl = dict(_POSIX_CTRL_CHARS)
|
||||
try:
|
||||
old = termios.tcgetattr(fd)
|
||||
cc = old[6] # Index 6 is the control characters array
|
||||
except (termios.error, OSError):
|
||||
return ctrl
|
||||
|
||||
# Use defaults for Backspace (BS) and Ctrl+A/E/K (SOH/ENQ/VT)
|
||||
# as they are not in the termios control characters array.
|
||||
for name in ('ERASE', 'KILL', 'WERASE', 'LNEXT', 'EOF', 'INTR'):
|
||||
cap = getattr(termios, f'V{name}')
|
||||
if cap < len(cc):
|
||||
ctrl[name] = cc[cap].decode('latin-1')
|
||||
return ctrl
|
||||
|
||||
|
||||
def unix_getpass(prompt='Password: ', stream=None, *, echo_char=None):
|
||||
"""Prompt for a password, with echo turned off.
|
||||
|
||||
Args:
|
||||
prompt: Written on stream to ask for the input. Default: 'Password: '
|
||||
stream: A writable file object to display the prompt. Defaults to
|
||||
the tty. If no tty is available defaults to sys.stderr.
|
||||
echo_char: A single ASCII character to mask input (e.g., '*').
|
||||
If None, input is hidden.
|
||||
Returns:
|
||||
The seKr3t input.
|
||||
Raises:
|
||||
EOFError: If our input tty or stdin was closed.
|
||||
GetPassWarning: When we were unable to turn echo off on the input.
|
||||
|
||||
Always restores terminal settings before returning.
|
||||
"""
|
||||
_check_echo_char(echo_char)
|
||||
|
||||
passwd = None
|
||||
with contextlib.ExitStack() as stack:
|
||||
try:
|
||||
# Always try reading and writing directly on the tty first.
|
||||
fd = os.open('/dev/tty', os.O_RDWR|os.O_NOCTTY)
|
||||
tty = io.FileIO(fd, 'w+')
|
||||
stack.enter_context(tty)
|
||||
input = io.TextIOWrapper(tty)
|
||||
stack.enter_context(input)
|
||||
if not stream:
|
||||
stream = input
|
||||
except OSError:
|
||||
# If that fails, see if stdin can be controlled.
|
||||
stack.close()
|
||||
try:
|
||||
fd = sys.stdin.fileno()
|
||||
except (AttributeError, ValueError):
|
||||
fd = None
|
||||
passwd = fallback_getpass(prompt, stream)
|
||||
input = sys.stdin
|
||||
if not stream:
|
||||
stream = sys.stderr
|
||||
|
||||
if fd is not None:
|
||||
try:
|
||||
old = termios.tcgetattr(fd) # a copy to save
|
||||
new = old[:]
|
||||
new[3] &= ~termios.ECHO # 3 == 'lflags'
|
||||
# Extract control characters before changing terminal mode.
|
||||
term_ctrl_chars = None
|
||||
if echo_char:
|
||||
# ICANON enables canonical (line-buffered) mode where
|
||||
# the terminal handles line editing. Disable it so we
|
||||
# can read input char by char and handle editing ourselves.
|
||||
new[3] &= ~termios.ICANON
|
||||
# IEXTEN enables implementation-defined input processing
|
||||
# such as LNEXT (Ctrl+V). Disable it so the terminal
|
||||
# driver does not intercept these characters before our
|
||||
# code can handle them.
|
||||
new[3] &= ~termios.IEXTEN
|
||||
term_ctrl_chars = _get_terminal_ctrl_chars(fd)
|
||||
tcsetattr_flags = termios.TCSAFLUSH
|
||||
if hasattr(termios, 'TCSASOFT'):
|
||||
tcsetattr_flags |= termios.TCSASOFT
|
||||
try:
|
||||
termios.tcsetattr(fd, tcsetattr_flags, new)
|
||||
passwd = _raw_input(prompt, stream, input=input,
|
||||
echo_char=echo_char,
|
||||
term_ctrl_chars=term_ctrl_chars)
|
||||
|
||||
finally:
|
||||
termios.tcsetattr(fd, tcsetattr_flags, old)
|
||||
stream.flush() # issue7208
|
||||
except termios.error:
|
||||
if passwd is not None:
|
||||
# _raw_input succeeded. The final tcsetattr failed. Reraise
|
||||
# instead of leaving the terminal in an unknown state.
|
||||
raise
|
||||
# We can't control the tty or stdin. Give up and use normal IO.
|
||||
# fallback_getpass() raises an appropriate warning.
|
||||
if stream is not input:
|
||||
# clean up unused file objects before blocking
|
||||
stack.close()
|
||||
passwd = fallback_getpass(prompt, stream)
|
||||
|
||||
stream.write('\n')
|
||||
return passwd
|
||||
|
||||
|
||||
def win_getpass(prompt='Password: ', stream=None, *, echo_char=None):
|
||||
"""Prompt for password with echo off, using Windows getwch()."""
|
||||
if sys.stdin is not sys.__stdin__:
|
||||
return fallback_getpass(prompt, stream)
|
||||
_check_echo_char(echo_char)
|
||||
|
||||
for c in prompt:
|
||||
msvcrt.putwch(c)
|
||||
pw = ""
|
||||
while 1:
|
||||
c = msvcrt.getwch()
|
||||
if c == '\r' or c == '\n':
|
||||
break
|
||||
if c == '\003':
|
||||
raise KeyboardInterrupt
|
||||
if c == '\b':
|
||||
if echo_char and pw:
|
||||
msvcrt.putwch('\b')
|
||||
msvcrt.putwch(' ')
|
||||
msvcrt.putwch('\b')
|
||||
pw = pw[:-1]
|
||||
else:
|
||||
pw = pw + c
|
||||
if echo_char:
|
||||
msvcrt.putwch(echo_char)
|
||||
msvcrt.putwch('\r')
|
||||
msvcrt.putwch('\n')
|
||||
return pw
|
||||
|
||||
|
||||
def fallback_getpass(prompt='Password: ', stream=None, *, echo_char=None):
|
||||
_check_echo_char(echo_char)
|
||||
import warnings
|
||||
warnings.warn("Can not control echo on the terminal.", GetPassWarning,
|
||||
stacklevel=2)
|
||||
if not stream:
|
||||
stream = sys.stderr
|
||||
print("Warning: Password input may be echoed.", file=stream)
|
||||
return _raw_input(prompt, stream, echo_char=echo_char)
|
||||
|
||||
|
||||
def _check_echo_char(echo_char):
|
||||
# Single-character ASCII excluding control characters
|
||||
if echo_char is None:
|
||||
return
|
||||
if not isinstance(echo_char, str):
|
||||
raise TypeError("'echo_char' must be a str or None, not "
|
||||
f"{type(echo_char).__name__}")
|
||||
if not (
|
||||
len(echo_char) == 1
|
||||
and echo_char.isprintable()
|
||||
and echo_char.isascii()
|
||||
):
|
||||
raise ValueError("'echo_char' must be a single printable ASCII "
|
||||
f"character, got: {echo_char!r}")
|
||||
|
||||
|
||||
def _raw_input(prompt="", stream=None, input=None, echo_char=None,
|
||||
term_ctrl_chars=None):
|
||||
# This doesn't save the string in the GNU readline history.
|
||||
if not stream:
|
||||
stream = sys.stderr
|
||||
if not input:
|
||||
input = sys.stdin
|
||||
prompt = str(prompt)
|
||||
if prompt:
|
||||
try:
|
||||
stream.write(prompt)
|
||||
except UnicodeEncodeError:
|
||||
# Use replace error handler to get as much as possible printed.
|
||||
prompt = prompt.encode(stream.encoding, 'replace')
|
||||
prompt = prompt.decode(stream.encoding)
|
||||
stream.write(prompt)
|
||||
stream.flush()
|
||||
# NOTE: The Python C API calls flockfile() (and unlock) during readline.
|
||||
if echo_char:
|
||||
return _readline_with_echo_char(stream, input, echo_char,
|
||||
term_ctrl_chars, prompt)
|
||||
line = input.readline()
|
||||
if not line:
|
||||
raise EOFError
|
||||
if line[-1] == '\n':
|
||||
line = line[:-1]
|
||||
return line
|
||||
|
||||
|
||||
def _readline_with_echo_char(stream, input, echo_char, term_ctrl_chars=None,
|
||||
prompt=""):
|
||||
"""Read password with echo character and line editing support."""
|
||||
if term_ctrl_chars is None:
|
||||
term_ctrl_chars = _POSIX_CTRL_CHARS
|
||||
|
||||
editor = _PasswordLineEditor(stream, echo_char, term_ctrl_chars, prompt)
|
||||
return editor.readline(input)
|
||||
|
||||
|
||||
class _PasswordLineEditor:
|
||||
"""Handles line editing for password input with echo character."""
|
||||
|
||||
def __init__(self, stream, echo_char, ctrl_chars, prompt=""):
|
||||
self.stream = stream
|
||||
self.echo_char = echo_char
|
||||
self.prompt = prompt
|
||||
self.password = []
|
||||
self.cursor_pos = 0
|
||||
self.eof_pressed = False
|
||||
self.literal_next = False
|
||||
self.ctrl = ctrl_chars
|
||||
self.dispatch = {
|
||||
ctrl_chars['SOH']: self.handle_move_start, # Ctrl+A
|
||||
ctrl_chars['ENQ']: self.handle_move_end, # Ctrl+E
|
||||
ctrl_chars['VT']: self.handle_kill_forward, # Ctrl+K
|
||||
ctrl_chars['KILL']: self.handle_kill_line, # Ctrl+U
|
||||
ctrl_chars['WERASE']: self.handle_erase_word, # Ctrl+W
|
||||
ctrl_chars['ERASE']: self.handle_erase, # DEL
|
||||
ctrl_chars['BS']: self.handle_erase, # Backspace
|
||||
# special characters
|
||||
ctrl_chars['LNEXT']: self.handle_literal_next, # Ctrl+V
|
||||
ctrl_chars['EOF']: self.handle_eof, # Ctrl+D
|
||||
ctrl_chars['INTR']: self.handle_interrupt, # Ctrl+C
|
||||
'\x00': self.handle_nop, # ignore NUL
|
||||
}
|
||||
|
||||
def refresh_display(self, prev_len=None):
|
||||
"""Redraw the entire password line with *echo_char*.
|
||||
|
||||
If *prev_len* is not specified, the current password length is used.
|
||||
"""
|
||||
prompt_len = len(self.prompt)
|
||||
clear_len = prev_len if prev_len is not None else len(self.password)
|
||||
# Clear the entire line (prompt + password) and rewrite.
|
||||
self.stream.write('\r' + ' ' * (prompt_len + clear_len) + '\r')
|
||||
self.stream.write(self.prompt + self.echo_char * len(self.password))
|
||||
if self.cursor_pos < len(self.password):
|
||||
self.stream.write('\b' * (len(self.password) - self.cursor_pos))
|
||||
self.stream.flush()
|
||||
|
||||
def insert_char(self, char):
|
||||
"""Insert *char* at cursor position."""
|
||||
self.password.insert(self.cursor_pos, char)
|
||||
self.cursor_pos += 1
|
||||
# Only refresh if inserting in middle.
|
||||
if self.cursor_pos < len(self.password):
|
||||
self.refresh_display()
|
||||
else:
|
||||
self.stream.write(self.echo_char)
|
||||
self.stream.flush()
|
||||
|
||||
def is_eol(self, char):
|
||||
"""Check if *char* is a line terminator."""
|
||||
return char in ('\r', '\n')
|
||||
|
||||
def is_eof(self, char):
|
||||
"""Check if *char* is a file terminator."""
|
||||
return char == self.ctrl['EOF']
|
||||
|
||||
def handle_move_start(self):
|
||||
"""Move cursor to beginning (Ctrl+A)."""
|
||||
self.cursor_pos = 0
|
||||
self.refresh_display()
|
||||
|
||||
def handle_move_end(self):
|
||||
"""Move cursor to end (Ctrl+E)."""
|
||||
self.cursor_pos = len(self.password)
|
||||
self.refresh_display()
|
||||
|
||||
def handle_erase(self):
|
||||
"""Delete character before cursor (Backspace/DEL)."""
|
||||
if self.cursor_pos == 0:
|
||||
return
|
||||
assert self.cursor_pos > 0
|
||||
self.cursor_pos -= 1
|
||||
prev_len = len(self.password)
|
||||
del self.password[self.cursor_pos]
|
||||
self.refresh_display(prev_len)
|
||||
|
||||
def handle_kill_line(self):
|
||||
"""Erase entire line (Ctrl+U)."""
|
||||
prev_len = len(self.password)
|
||||
self.password.clear()
|
||||
self.cursor_pos = 0
|
||||
self.refresh_display(prev_len)
|
||||
|
||||
def handle_kill_forward(self):
|
||||
"""Kill from cursor to end (Ctrl+K)."""
|
||||
prev_len = len(self.password)
|
||||
del self.password[self.cursor_pos:]
|
||||
self.refresh_display(prev_len)
|
||||
|
||||
def handle_erase_word(self):
|
||||
"""Erase previous word (Ctrl+W)."""
|
||||
old_cursor = self.cursor_pos
|
||||
# Calculate the starting position of the previous word,
|
||||
# ignoring trailing whitespaces.
|
||||
while self.cursor_pos > 0 and self.password[self.cursor_pos - 1] == ' ':
|
||||
self.cursor_pos -= 1
|
||||
while self.cursor_pos > 0 and self.password[self.cursor_pos - 1] != ' ':
|
||||
self.cursor_pos -= 1
|
||||
# Delete the previous word and refresh the screen.
|
||||
prev_len = len(self.password)
|
||||
del self.password[self.cursor_pos:old_cursor]
|
||||
self.refresh_display(prev_len)
|
||||
|
||||
def handle_literal_next(self):
|
||||
"""State transition to indicate that the next character is literal."""
|
||||
assert self.literal_next is False
|
||||
self.literal_next = True
|
||||
|
||||
def handle_eof(self):
|
||||
"""State transition to indicate that the pressed character was EOF."""
|
||||
assert self.eof_pressed is False
|
||||
self.eof_pressed = True
|
||||
|
||||
def handle_interrupt(self):
|
||||
"""Raise a KeyboardInterrupt after Ctrl+C has been received."""
|
||||
raise KeyboardInterrupt
|
||||
|
||||
def handle_nop(self):
|
||||
"""Handler for an ignored character."""
|
||||
|
||||
def handle(self, char):
|
||||
"""Handle a single character input. Returns True if handled."""
|
||||
handler = self.dispatch.get(char)
|
||||
if handler:
|
||||
handler()
|
||||
return True
|
||||
return False
|
||||
|
||||
def readline(self, input):
|
||||
"""Read a line of password input with echo character support."""
|
||||
while True:
|
||||
assert self.cursor_pos >= 0
|
||||
char = input.read(1)
|
||||
if self.is_eol(char):
|
||||
break
|
||||
# Handle literal next mode first as Ctrl+V quotes characters.
|
||||
elif self.literal_next:
|
||||
self.insert_char(char)
|
||||
self.literal_next = False
|
||||
# Handle EOF now as Ctrl+D must be pressed twice
|
||||
# consecutively to stop reading from the input.
|
||||
elif self.is_eof(char):
|
||||
if self.eof_pressed:
|
||||
break
|
||||
elif self.handle(char):
|
||||
# Dispatched to handler.
|
||||
pass
|
||||
else:
|
||||
# Insert as normal character.
|
||||
self.insert_char(char)
|
||||
|
||||
self.eof_pressed = self.is_eof(char)
|
||||
|
||||
return ''.join(self.password)
|
||||
|
||||
|
||||
def getuser():
|
||||
"""Get the username from the environment or password database.
|
||||
|
||||
First try various environment variables, then the password
|
||||
database. This works on Windows as long as USERNAME is set.
|
||||
Any failure to find a username raises OSError.
|
||||
|
||||
.. versionchanged:: 3.13
|
||||
Previously, various exceptions beyond just :exc:`OSError`
|
||||
were raised.
|
||||
"""
|
||||
|
||||
for name in ('LOGNAME', 'USER', 'LNAME', 'USERNAME'):
|
||||
user = os.environ.get(name)
|
||||
if user:
|
||||
return user
|
||||
|
||||
try:
|
||||
import pwd
|
||||
return pwd.getpwuid(os.getuid())[0]
|
||||
except (ImportError, KeyError) as e:
|
||||
raise OSError('No username set in the environment') from e
|
||||
|
||||
|
||||
# Bind the name getpass to the appropriate function
|
||||
try:
|
||||
import termios
|
||||
# it's possible there is an incompatible termios from the
|
||||
# McMillan Installer, make sure we have a UNIX-compatible termios
|
||||
termios.tcgetattr, termios.tcsetattr
|
||||
except (ImportError, AttributeError):
|
||||
try:
|
||||
import msvcrt
|
||||
except ImportError:
|
||||
getpass = fallback_getpass
|
||||
else:
|
||||
getpass = win_getpass
|
||||
else:
|
||||
getpass = unix_getpass
|
||||
Reference in New Issue
Block a user