text stringlengths 81 112k |
|---|
Deal properly with inserted chars in a line.
def _readline_insert(self, char, echo, insptr, line):
"""Deal properly with inserted chars in a line."""
if not self._readline_do_echo(echo):
return
# Write out the remainder of the line
self.write(char + ''.join(line[insptr:]))
# Cursor Left to the current insert point
char_count = len(line) - insptr
self.write(self.CODES['CSRLEFT'] * char_count) |
Handles reading ANSI escape sequences
def ansi_to_curses(self, char):
'''Handles reading ANSI escape sequences'''
# ANSI sequences are:
# ESC [ <key>
# If we see ESC, read a char
if char != ESC:
return char
# If we see [, read another char
if self.getc(block=True) != ANSI_START_SEQ:
self._readline_echo(BELL, True)
return theNULL
key = self.getc(block=True)
# Translate the key to curses
try:
return ANSI_KEY_TO_CURSES[key]
except:
self._readline_echo(BELL, True)
return theNULL |
Return a line of text, including the terminating LF
If echo is true always echo, if echo is false never echo
If echo is None follow the negotiated setting.
prompt is the current prompt to write (and rewrite if needed)
use_history controls if this current line uses (and adds to) the command history.
def readline(self, echo=None, prompt='', use_history=True):
"""Return a line of text, including the terminating LF
If echo is true always echo, if echo is false never echo
If echo is None follow the negotiated setting.
prompt is the current prompt to write (and rewrite if needed)
use_history controls if this current line uses (and adds to) the command history.
"""
line = []
insptr = 0
ansi = 0
histptr = len(self.history)
if self.DOECHO:
self.write(prompt)
self._current_prompt = prompt
else:
self._current_prompt = ''
self._current_line = ''
while True:
c = self.getc(block=True)
c = self.ansi_to_curses(c)
if c == theNULL:
continue
elif c == curses.KEY_LEFT:
if insptr > 0:
insptr = insptr - 1
self._readline_echo(self.CODES['CSRLEFT'], echo)
else:
self._readline_echo(BELL, echo)
continue
elif c == curses.KEY_RIGHT:
if insptr < len(line):
insptr = insptr + 1
self._readline_echo(self.CODES['CSRRIGHT'], echo)
else:
self._readline_echo(BELL, echo)
continue
elif c == curses.KEY_UP or c == curses.KEY_DOWN:
if not use_history:
self._readline_echo(BELL, echo)
continue
if c == curses.KEY_UP:
if histptr > 0:
histptr = histptr - 1
else:
self._readline_echo(BELL, echo)
continue
elif c == curses.KEY_DOWN:
if histptr < len(self.history):
histptr = histptr + 1
else:
self._readline_echo(BELL, echo)
continue
line = []
if histptr < len(self.history):
line.extend(self.history[histptr])
for char in range(insptr):
self._readline_echo(self.CODES['CSRLEFT'], echo)
self._readline_echo(self.CODES['DEOL'], echo)
self._readline_echo(''.join(line), echo)
insptr = len(line)
continue
elif c == chr(3):
self._readline_echo('\n' + curses.ascii.unctrl(c) + ' ABORT\n', echo)
return ''
elif c == chr(4):
if len(line) > 0:
self._readline_echo('\n' + curses.ascii.unctrl(c) + ' ABORT (QUIT)\n', echo)
return ''
self._readline_echo('\n' + curses.ascii.unctrl(c) + ' QUIT\n', echo)
return 'QUIT'
elif c == chr(10):
self._readline_echo(c, echo)
result = ''.join(line)
if use_history:
self.history.append(result)
if echo is False:
if prompt:
self.write( chr(10) )
log.debug('readline: %s(hidden text)', prompt)
else:
log.debug('readline: %s%r', prompt, result)
return result
elif c == curses.KEY_BACKSPACE or c == chr(127) or c == chr(8):
if insptr > 0:
self._readline_echo(self.CODES['CSRLEFT'] + self.CODES['DEL'], echo)
insptr = insptr - 1
del line[insptr]
else:
self._readline_echo(BELL, echo)
continue
elif c == curses.KEY_DC:
if insptr < len(line):
self._readline_echo(self.CODES['DEL'], echo)
del line[insptr]
else:
self._readline_echo(BELL, echo)
continue
else:
if ord(c) < 32:
c = curses.ascii.unctrl(c)
if len(line) > insptr:
self._readline_insert(c, echo, insptr, line)
else:
self._readline_echo(c, echo)
line[insptr:insptr] = c
insptr = insptr + len(c)
if self._readline_do_echo(echo):
self._current_line = line |
Send a packet with line ending.
def writeline(self, text):
"""Send a packet with line ending."""
log.debug('writing line %r' % text)
self.write(text+chr(10)) |
Write out an asynchronous message, then reconstruct the prompt and entered text.
def writemessage(self, text):
"""Write out an asynchronous message, then reconstruct the prompt and entered text."""
log.debug('writing message %r', text)
self.write(chr(10)+text+chr(10))
self.write(self._current_prompt+''.join(self._current_line)) |
Send a packet to the socket. This function cooks output.
def write(self, text):
"""Send a packet to the socket. This function cooks output."""
text = str(text) # eliminate any unicode or other snigglets
text = text.replace(IAC, IAC+IAC)
text = text.replace(chr(10), chr(13)+chr(10))
self.writecooked(text) |
Get one character from the raw queue. Optionally blocking.
Raise EOFError on end of stream. SHOULD ONLY BE CALLED FROM THE
INPUT COOKER.
def _inputcooker_getc(self, block=True):
"""Get one character from the raw queue. Optionally blocking.
Raise EOFError on end of stream. SHOULD ONLY BE CALLED FROM THE
INPUT COOKER."""
if self.rawq:
ret = self.rawq[0]
self.rawq = self.rawq[1:]
return ret
if not block:
if not self.inputcooker_socket_ready():
return ''
ret = self.sock.recv(20)
self.eof = not(ret)
self.rawq = self.rawq + ret
if self.eof:
raise EOFError
return self._inputcooker_getc(block) |
Put the cooked data in the correct queue
def _inputcooker_store(self, char):
"""Put the cooked data in the correct queue"""
if self.sb:
self.sbdataq = self.sbdataq + char
else:
self.inputcooker_store_queue(char) |
Input Cooker - Transfer from raw queue to cooked queue.
Set self.eof when connection is closed. Don't block unless in
the midst of an IAC sequence.
def inputcooker(self):
"""Input Cooker - Transfer from raw queue to cooked queue.
Set self.eof when connection is closed. Don't block unless in
the midst of an IAC sequence.
"""
try:
while True:
c = self._inputcooker_getc()
if not self.iacseq:
if c == IAC:
self.iacseq += c
continue
elif c == chr(13) and not(self.sb):
c2 = self._inputcooker_getc(block=False)
if c2 == theNULL or c2 == '':
c = chr(10)
elif c2 == chr(10):
c = c2
else:
self._inputcooker_ungetc(c2)
c = chr(10)
elif c in [x[0] for x in self.ESCSEQ.keys()]:
'Looks like the begining of a key sequence'
codes = c
for keyseq in self.ESCSEQ.keys():
if len(keyseq) == 0:
continue
while codes == keyseq[:len(codes)] and len(codes) <= keyseq:
if codes == keyseq:
c = self.ESCSEQ[keyseq]
break
codes = codes + self._inputcooker_getc()
if codes == keyseq:
break
self._inputcooker_ungetc(codes[1:])
codes = codes[0]
self._inputcooker_store(c)
elif len(self.iacseq) == 1:
'IAC: IAC CMD [OPTION only for WILL/WONT/DO/DONT]'
if c in (DO, DONT, WILL, WONT):
self.iacseq += c
continue
self.iacseq = ''
if c == IAC:
self._inputcooker_store(c)
else:
if c == SB: # SB ... SE start.
self.sb = 1
self.sbdataq = ''
elif c == SE: # SB ... SE end.
self.sb = 0
# Callback is supposed to look into
# the sbdataq
self.options_handler(self.sock, c, NOOPT)
elif len(self.iacseq) == 2:
cmd = self.iacseq[1]
self.iacseq = ''
if cmd in (DO, DONT, WILL, WONT):
self.options_handler(self.sock, cmd, c)
except (EOFError, socket.error):
pass |
[<command>]
Display help
Display either brief help on all commands, or detailed
help on a single command passed as a parameter.
def cmdHELP(self, params):
"""[<command>]
Display help
Display either brief help on all commands, or detailed
help on a single command passed as a parameter.
"""
if params:
cmd = params[0].upper()
if self.COMMANDS.has_key(cmd):
method = self.COMMANDS[cmd]
doc = method.__doc__.split("\n")
docp = doc[0].strip()
docl = '\n'.join( [l.strip() for l in doc[2:]] )
if not docl.strip(): # If there isn't anything here, use line 1
docl = doc[1].strip()
self.writeline(
"%s %s\n\n%s" % (
cmd,
docp,
docl,
)
)
return
else:
self.writeline("Command '%s' not known" % cmd)
else:
self.writeline("Help on built in commands\n")
keys = self.COMMANDS.keys()
keys.sort()
for cmd in keys:
method = self.COMMANDS[cmd]
if getattr(method, 'hidden', False):
continue
if method.__doc__ == None:
self.writeline("no help for command %s" % method)
return
doc = method.__doc__.split("\n")
docp = doc[0].strip()
docs = doc[1].strip()
if len(docp) > 0:
docps = "%s - %s" % (docp, docs, )
else:
docps = "- %s" % (docs, )
self.writeline(
"%s %s" % (
cmd,
docps,
)
) |
Display the command history
def cmdHISTORY(self, params):
"""
Display the command history
"""
cnt = 0
self.writeline('Command history\n')
for line in self.history:
cnt = cnt + 1
self.writeline("%-5d : %s" % (cnt, ''.join(line))) |
Exception handler (False to abort)
def handleException(self, exc_type, exc_param, exc_tb):
"Exception handler (False to abort)"
self.writeline(''.join( traceback.format_exception(exc_type, exc_param, exc_tb) ))
return True |
Checks the authentication and sets the username of the currently connected terminal. Returns True or False
def authentication_ok(self):
'''Checks the authentication and sets the username of the currently connected terminal. Returns True or False'''
username = None
password = None
if self.authCallback:
if self.authNeedUser:
username = self.readline(prompt=self.PROMPT_USER, use_history=False)
if self.authNeedPass:
password = self.readline(echo=False, prompt=self.PROMPT_PASS, use_history=False)
if self.DOECHO:
self.write("\n")
try:
self.authCallback(username, password)
except:
self.username = None
return False
else:
# Successful authentication
self.username = username
return True
else:
# No authentication desired
self.username = None
return True |
The actual service to which the user has connected.
def handle(self):
"The actual service to which the user has connected."
if self.TELNET_ISSUE:
self.writeline(self.TELNET_ISSUE)
if not self.authentication_ok():
return
if self.DOECHO:
self.writeline(self.WELCOME)
self.session_start()
while self.RUNSHELL:
raw_input = self.readline(prompt=self.PROMPT).strip()
self.input = self.input_reader(self, raw_input)
self.raw_input = self.input.raw
if self.input.cmd:
cmd = self.input.cmd.upper()
params = self.input.params
if self.COMMANDS.has_key(cmd):
try:
self.COMMANDS[cmd](params)
except:
log.exception('Error calling %s.' % cmd)
(t, p, tb) = sys.exc_info()
if self.handleException(t, p, tb):
break
else:
self.writeerror("Unknown command '%s'" % cmd)
log.debug("Exiting handler") |
Called after instantiation
def setup(self):
'''Called after instantiation'''
TelnetHandlerBase.setup(self)
# Spawn a greenlet to handle socket input
self.greenlet_ic = gevent.spawn(self.inputcooker)
# Note that inputcooker exits on EOF
# Sleep for 0.5 second to allow options negotiation
gevent.sleep(0.5) |
Return one character from the input queue
def getc(self, block=True):
"""Return one character from the input queue"""
try:
return self.cookedq.get(block)
except gevent.queue.Empty:
return '' |
Request an authentication order. The :py:meth:`collect` method
is used to query the status of the order.
:param personal_number: The Swedish personal number
in format YYYYMMDDXXXX.
:type personal_number: str
:return: The OrderResponse parsed to a dictionary.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
def authenticate(self, personal_number, **kwargs):
"""Request an authentication order. The :py:meth:`collect` method
is used to query the status of the order.
:param personal_number: The Swedish personal number
in format YYYYMMDDXXXX.
:type personal_number: str
:return: The OrderResponse parsed to a dictionary.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
"""
if "requirementAlternatives" in kwargs:
warnings.warn(
"Requirement Alternatives " "option is not tested.", BankIDWarning
)
try:
out = self.client.service.Authenticate(
personalNumber=personal_number, **kwargs
)
except Error as e:
raise get_error_class(e, "Could not complete Authenticate order.")
return self._dictify(out) |
Request an signing order. The :py:meth:`collect` method
is used to query the status of the order.
:param user_visible_data: The information that the end user is
requested to sign.
:type user_visible_data: str
:param personal_number: The Swedish personal number in
format YYYYMMDDXXXX.
:type personal_number: str
:return: The OrderResponse parsed to a dictionary.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
def sign(self, user_visible_data, personal_number=None, **kwargs):
"""Request an signing order. The :py:meth:`collect` method
is used to query the status of the order.
:param user_visible_data: The information that the end user is
requested to sign.
:type user_visible_data: str
:param personal_number: The Swedish personal number in
format YYYYMMDDXXXX.
:type personal_number: str
:return: The OrderResponse parsed to a dictionary.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
"""
if "requirementAlternatives" in kwargs:
warnings.warn(
"Requirement Alternatives option is not tested.", BankIDWarning
)
if isinstance(user_visible_data, six.text_type):
data = base64.b64encode(user_visible_data.encode("utf-8")).decode("ascii")
else:
data = base64.b64encode(user_visible_data).decode("ascii")
try:
out = self.client.service.Sign(
userVisibleData=data, personalNumber=personal_number, **kwargs
)
except Error as e:
raise get_error_class(e, "Could not complete Sign order.")
return self._dictify(out) |
Collect the progress status of the order with the specified
order reference.
:param order_ref: The UUID string specifying which order to
collect status from.
:type order_ref: str
:return: The CollectResponse parsed to a dictionary.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
def collect(self, order_ref):
"""Collect the progress status of the order with the specified
order reference.
:param order_ref: The UUID string specifying which order to
collect status from.
:type order_ref: str
:return: The CollectResponse parsed to a dictionary.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
"""
try:
out = self.client.service.Collect(order_ref)
except Error as e:
raise get_error_class(e, "Could not complete Collect call.")
return self._dictify(out) |
Transforms the replies to a regular Python dict with
strings and datetimes.
Tested with BankID version 2.5 return data.
:param doc: The response as interpreted by :py:mod:`zeep`.
:returns: The response parsed to a dict.
:rtype: dict
def _dictify(self, doc):
"""Transforms the replies to a regular Python dict with
strings and datetimes.
Tested with BankID version 2.5 return data.
:param doc: The response as interpreted by :py:mod:`zeep`.
:returns: The response parsed to a dict.
:rtype: dict
"""
return {
k: (self._dictify(doc[k]) if hasattr(doc[k], "_xsd_type") else doc[k])
for k in doc
} |
Load all image formats if needed.
def intercept_image_formats(self, options):
"""
Load all image formats if needed.
"""
if 'entityTypes' in options:
for entity in options['entityTypes']:
if entity['type'] == ENTITY_TYPES.IMAGE and 'imageFormats' in entity:
if entity['imageFormats'] == '__all__':
entity['imageFormats'] = get_all_image_formats()
return options |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._timestamp is not None:
self._normalized_timestamp = decimal.Decimal(self._timestamp)
return self._normalized_timestamp |
Copies a POSIX timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
def CopyFromDateTimeString(self, time_string):
"""Copies a POSIX timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
"""
date_time_values = self._CopyDateTimeFromString(time_string)
year = date_time_values.get('year', 0)
month = date_time_values.get('month', 0)
day_of_month = date_time_values.get('day_of_month', 0)
hours = date_time_values.get('hours', 0)
minutes = date_time_values.get('minutes', 0)
seconds = date_time_values.get('seconds', 0)
self._timestamp = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
self.is_local_time = False |
Copies the POSIX timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss" or None
if the timestamp is missing.
def CopyToDateTimeString(self):
"""Copies the POSIX timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss" or None
if the timestamp is missing.
"""
if self._timestamp is None:
return None
number_of_days, hours, minutes, seconds = self._GetTimeValues(
self._timestamp)
year, month, day_of_month = self._GetDateValuesWithEpoch(
number_of_days, self._EPOCH)
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}'.format(
year, month, day_of_month, hours, minutes, seconds) |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._timestamp is not None:
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) /
definitions.MILLISECONDS_PER_SECOND)
return self._normalized_timestamp |
Copies a POSIX timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
def CopyFromDateTimeString(self, time_string):
"""Copies a POSIX timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
"""
date_time_values = self._CopyDateTimeFromString(time_string)
year = date_time_values.get('year', 0)
month = date_time_values.get('month', 0)
day_of_month = date_time_values.get('day_of_month', 0)
hours = date_time_values.get('hours', 0)
minutes = date_time_values.get('minutes', 0)
seconds = date_time_values.get('seconds', 0)
microseconds = date_time_values.get('microseconds', 0)
timestamp = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
timestamp *= definitions.MILLISECONDS_PER_SECOND
if microseconds:
milliseconds, _ = divmod(
microseconds, definitions.MILLISECONDS_PER_SECOND)
timestamp += milliseconds
self._timestamp = timestamp
self.is_local_time = False |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._timestamp is not None:
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) /
definitions.MICROSECONDS_PER_SECOND)
return self._normalized_timestamp |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._timestamp is not None:
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) /
definitions.NANOSECONDS_PER_SECOND)
return self._normalized_timestamp |
Copies a POSIX timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
def _CopyFromDateTimeString(self, time_string):
"""Copies a POSIX timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
"""
date_time_values = self._CopyDateTimeFromString(time_string)
year = date_time_values.get('year', 0)
month = date_time_values.get('month', 0)
day_of_month = date_time_values.get('day_of_month', 0)
hours = date_time_values.get('hours', 0)
minutes = date_time_values.get('minutes', 0)
seconds = date_time_values.get('seconds', 0)
microseconds = date_time_values.get('microseconds', None)
timestamp = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
timestamp *= definitions.NANOSECONDS_PER_SECOND
if microseconds:
nanoseconds = microseconds * definitions.MILLISECONDS_PER_SECOND
timestamp += nanoseconds
self._normalized_timestamp = None
self._timestamp = timestamp |
Copies the POSIX timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#########" or
None if the timestamp is missing or invalid.
def _CopyToDateTimeString(self):
"""Copies the POSIX timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#########" or
None if the timestamp is missing or invalid.
"""
if self._timestamp is None:
return None
timestamp, nanoseconds = divmod(
self._timestamp, definitions.NANOSECONDS_PER_SECOND)
number_of_days, hours, minutes, seconds = self._GetTimeValues(timestamp)
year, month, day_of_month = self._GetDateValuesWithEpoch(
number_of_days, self._EPOCH)
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:09d}'.format(
year, month, day_of_month, hours, minutes, seconds, nanoseconds) |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._timestamp is not None:
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) - self._DELPHI_TO_POSIX_BASE)
self._normalized_timestamp *= definitions.SECONDS_PER_DAY
return self._normalized_timestamp |
Copies a Delphi TDateTime timestamp from a string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
Raises:
ValueError: if the time string is invalid or not supported.
def CopyFromDateTimeString(self, time_string):
"""Copies a Delphi TDateTime timestamp from a string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
Raises:
ValueError: if the time string is invalid or not supported.
"""
date_time_values = self._CopyDateTimeFromString(time_string)
year = date_time_values.get('year', 0)
month = date_time_values.get('month', 0)
day_of_month = date_time_values.get('day_of_month', 0)
hours = date_time_values.get('hours', 0)
minutes = date_time_values.get('minutes', 0)
seconds = date_time_values.get('seconds', 0)
microseconds = date_time_values.get('microseconds', None)
if year > 9999:
raise ValueError('Unsupported year value: {0:d}.'.format(year))
timestamp = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
timestamp = float(timestamp) / definitions.SECONDS_PER_DAY
timestamp += self._DELPHI_TO_POSIX_BASE
if microseconds is not None:
timestamp += float(microseconds) / definitions.MICROSECONDS_PER_DAY
self._normalized_timestamp = None
self._timestamp = timestamp
self.is_local_time = False |
Retrieves the normalized timestamp.
Returns:
float: normalized timestamp, which contains the number of seconds since
January 1, 1970 00:00:00 and a fraction of second used for increased
precision, or None if the normalized timestamp cannot be determined.
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
float: normalized timestamp, which contains the number of seconds since
January 1, 1970 00:00:00 and a fraction of second used for increased
precision, or None if the normalized timestamp cannot be determined.
"""
if self._normalized_timestamp is None:
if (self._timestamp is not None and self._timestamp >= self._INT64_MIN and
self._timestamp <= self._INT64_MAX):
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) /
definitions.MICROSECONDS_PER_SECOND)
self._normalized_timestamp -= self._WEBKIT_TO_POSIX_BASE
return self._normalized_timestamp |
Adjusts the date and time values for a time zone offset.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
day_of_month (int): day of the month, where 1 represents the first day.
hours (int): hours.
minutes (int): minutes.
time_zone_offset (int): time zone offset in number of minutes from UTC.
Returns:
tuple[int, int, int, int, int, int]: time zone correct year, month,
day_of_month, hours and minutes values.
def _AdjustForTimeZoneOffset(
self, year, month, day_of_month, hours, minutes, time_zone_offset):
"""Adjusts the date and time values for a time zone offset.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
day_of_month (int): day of the month, where 1 represents the first day.
hours (int): hours.
minutes (int): minutes.
time_zone_offset (int): time zone offset in number of minutes from UTC.
Returns:
tuple[int, int, int, int, int, int]: time zone correct year, month,
day_of_month, hours and minutes values.
"""
hours_from_utc, minutes_from_utc = divmod(time_zone_offset, 60)
minutes += minutes_from_utc
# Since divmod makes sure the sign of minutes_from_utc is positive
# we only need to check the upper bound here, because hours_from_utc
# remains signed it is corrected accordingly.
if minutes >= 60:
minutes -= 60
hours += 1
hours += hours_from_utc
if hours < 0:
hours += 24
day_of_month -= 1
elif hours >= 24:
hours -= 24
day_of_month += 1
days_per_month = self._GetDaysPerMonth(year, month)
if day_of_month < 1:
month -= 1
if month < 1:
month = 12
year -= 1
day_of_month += self._GetDaysPerMonth(year, month)
elif day_of_month > days_per_month:
month += 1
if month > 12:
month = 1
year += 1
day_of_month -= days_per_month
return year, month, day_of_month, hours, minutes |
Copies a date from a string.
Args:
date_string (str): date value formatted as: YYYY-MM-DD
Returns:
tuple[int, int, int]: year, month, day of month.
Raises:
ValueError: if the date string is invalid or not supported.
def _CopyDateFromString(self, date_string):
"""Copies a date from a string.
Args:
date_string (str): date value formatted as: YYYY-MM-DD
Returns:
tuple[int, int, int]: year, month, day of month.
Raises:
ValueError: if the date string is invalid or not supported.
"""
date_string_length = len(date_string)
# The date string should at least contain 'YYYY-MM-DD'.
if date_string_length < 10:
raise ValueError('Date string too short.')
if date_string[4] != '-' or date_string[7] != '-':
raise ValueError('Invalid date string.')
try:
year = int(date_string[0:4], 10)
except ValueError:
raise ValueError('Unable to parse year.')
try:
month = int(date_string[5:7], 10)
except ValueError:
raise ValueError('Unable to parse month.')
try:
day_of_month = int(date_string[8:10], 10)
except ValueError:
raise ValueError('Unable to parse day of month.')
days_per_month = self._GetDaysPerMonth(year, month)
if day_of_month < 1 or day_of_month > days_per_month:
raise ValueError('Day of month value out of bounds.')
return year, month, day_of_month |
Copies a time from a string.
Args:
time_string (str): time value formatted as:
hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The seconds fraction and
time zone offset are optional.
Returns:
tuple[int, int, int, int, int]: hours, minutes, seconds, microseconds,
time zone offset in minutes.
Raises:
ValueError: if the time string is invalid or not supported.
def _CopyTimeFromString(self, time_string):
"""Copies a time from a string.
Args:
time_string (str): time value formatted as:
hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The seconds fraction and
time zone offset are optional.
Returns:
tuple[int, int, int, int, int]: hours, minutes, seconds, microseconds,
time zone offset in minutes.
Raises:
ValueError: if the time string is invalid or not supported.
"""
time_string_length = len(time_string)
# The time string should at least contain 'hh:mm:ss'.
if time_string_length < 8:
raise ValueError('Time string too short.')
if time_string[2] != ':' or time_string[5] != ':':
raise ValueError('Invalid time string.')
try:
hours = int(time_string[0:2], 10)
except ValueError:
raise ValueError('Unable to parse hours.')
if hours not in range(0, 24):
raise ValueError('Hours value: {0:d} out of bounds.'.format(hours))
try:
minutes = int(time_string[3:5], 10)
except ValueError:
raise ValueError('Unable to parse minutes.')
if minutes not in range(0, 60):
raise ValueError('Minutes value: {0:d} out of bounds.'.format(minutes))
try:
seconds = int(time_string[6:8], 10)
except ValueError:
raise ValueError('Unable to parse day of seconds.')
# TODO: support a leap second?
if seconds not in range(0, 60):
raise ValueError('Seconds value: {0:d} out of bounds.'.format(seconds))
microseconds = None
time_zone_offset = None
time_zone_string_index = 8
while time_zone_string_index < time_string_length:
if time_string[time_zone_string_index] in ('+', '-'):
break
time_zone_string_index += 1
# The calculations that follow rely on the time zone string index
# to point beyond the string in case no time zone offset was defined.
if time_zone_string_index == time_string_length - 1:
time_zone_string_index += 1
if time_string_length > 8 and time_string[8] == '.':
time_fraction_length = time_zone_string_index - 9
if time_fraction_length not in (3, 6):
raise ValueError('Invalid time string.')
try:
time_fraction = time_string[9:time_zone_string_index]
time_fraction = int(time_fraction, 10)
except ValueError:
raise ValueError('Unable to parse time fraction.')
if time_fraction_length == 3:
time_fraction *= 1000
microseconds = time_fraction
if time_zone_string_index < time_string_length:
if (time_string_length - time_zone_string_index != 6 or
time_string[time_zone_string_index + 3] != ':'):
raise ValueError('Invalid time string.')
try:
hours_from_utc = int(time_string[
time_zone_string_index + 1:time_zone_string_index + 3])
except ValueError:
raise ValueError('Unable to parse time zone hours offset.')
if hours_from_utc not in range(0, 15):
raise ValueError('Time zone hours offset value out of bounds.')
try:
minutes_from_utc = int(time_string[
time_zone_string_index + 4:time_zone_string_index + 6])
except ValueError:
raise ValueError('Unable to parse time zone minutes offset.')
if minutes_from_utc not in range(0, 60):
raise ValueError('Time zone minutes offset value out of bounds.')
# pylint: disable=invalid-unary-operand-type
time_zone_offset = (hours_from_utc * 60) + minutes_from_utc
# Note that when the sign of the time zone offset is negative
# the difference needs to be added. We do so by flipping the sign.
if time_string[time_zone_string_index] != '-':
time_zone_offset = -time_zone_offset
return hours, minutes, seconds, microseconds, time_zone_offset |
Determines date values.
Args:
number_of_days (int): number of days since epoch.
epoch_year (int): year that is the start of the epoch e.g. 1970.
epoch_month (int): month that is the start of the epoch, where
1 represents January.
epoch_day_of_month (int): day of month that is the start of the epoch,
where 1 represents the first day.
Returns:
tuple[int, int, int]: year, month, day of month.
Raises:
ValueError: if the epoch year, month or day of month values are out
of bounds.
def _GetDateValues(
self, number_of_days, epoch_year, epoch_month, epoch_day_of_month):
"""Determines date values.
Args:
number_of_days (int): number of days since epoch.
epoch_year (int): year that is the start of the epoch e.g. 1970.
epoch_month (int): month that is the start of the epoch, where
1 represents January.
epoch_day_of_month (int): day of month that is the start of the epoch,
where 1 represents the first day.
Returns:
tuple[int, int, int]: year, month, day of month.
Raises:
ValueError: if the epoch year, month or day of month values are out
of bounds.
"""
if epoch_year < 0:
raise ValueError('Epoch year value: {0:d} out of bounds.'.format(
epoch_year))
if epoch_month not in range(1, 13):
raise ValueError('Epoch month value: {0:d} out of bounds.'.format(
epoch_month))
epoch_days_per_month = self._GetDaysPerMonth(epoch_year, epoch_month)
if epoch_day_of_month < 1 or epoch_day_of_month > epoch_days_per_month:
raise ValueError('Epoch day of month value: {0:d} out of bounds.'.format(
epoch_day_of_month))
before_epoch = number_of_days < 0
year = epoch_year
month = epoch_month
if before_epoch:
month -= 1
if month <= 0:
month = 12
year -= 1
number_of_days += epoch_day_of_month
if before_epoch:
number_of_days *= -1
# Align with the start of the year.
while month > 1:
days_per_month = self._GetDaysPerMonth(year, month)
if number_of_days < days_per_month:
break
if before_epoch:
month -= 1
else:
month += 1
if month > 12:
month = 1
year += 1
number_of_days -= days_per_month
# Align with the start of the next century.
_, remainder = divmod(year, 100)
for _ in range(remainder, 100):
days_in_year = self._GetNumberOfDaysInYear(year)
if number_of_days < days_in_year:
break
if before_epoch:
year -= 1
else:
year += 1
number_of_days -= days_in_year
days_in_century = self._GetNumberOfDaysInCentury(year)
while number_of_days > days_in_century:
if before_epoch:
year -= 100
else:
year += 100
number_of_days -= days_in_century
days_in_century = self._GetNumberOfDaysInCentury(year)
days_in_year = self._GetNumberOfDaysInYear(year)
while number_of_days > days_in_year:
if before_epoch:
year -= 1
else:
year += 1
number_of_days -= days_in_year
days_in_year = self._GetNumberOfDaysInYear(year)
days_per_month = self._GetDaysPerMonth(year, month)
while number_of_days > days_per_month:
if before_epoch:
month -= 1
else:
month += 1
if month <= 0:
month = 12
year -= 1
elif month > 12:
month = 1
year += 1
number_of_days -= days_per_month
days_per_month = self._GetDaysPerMonth(year, month)
if before_epoch:
days_per_month = self._GetDaysPerMonth(year, month)
number_of_days = days_per_month - number_of_days
elif number_of_days == 0:
number_of_days = 31
month = 12
year -= 1
return year, month, number_of_days |
Determines date values.
Args:
number_of_days (int): number of days since epoch.
date_time_epoch (DateTimeEpoch): date and time of the epoch.
Returns:
tuple[int, int, int]: year, month, day of month.
def _GetDateValuesWithEpoch(self, number_of_days, date_time_epoch):
"""Determines date values.
Args:
number_of_days (int): number of days since epoch.
date_time_epoch (DateTimeEpoch): date and time of the epoch.
Returns:
tuple[int, int, int]: year, month, day of month.
"""
return self._GetDateValues(
number_of_days, date_time_epoch.year, date_time_epoch.month,
date_time_epoch.day_of_month) |
Retrieves the day of the year for a specific day of a month in a year.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
day_of_month (int): day of the month, where 1 represents the first day.
Returns:
int: day of year.
Raises:
ValueError: if the month or day of month value is out of bounds.
def _GetDayOfYear(self, year, month, day_of_month):
"""Retrieves the day of the year for a specific day of a month in a year.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
day_of_month (int): day of the month, where 1 represents the first day.
Returns:
int: day of year.
Raises:
ValueError: if the month or day of month value is out of bounds.
"""
if month not in range(1, 13):
raise ValueError('Month value out of bounds.')
days_per_month = self._GetDaysPerMonth(year, month)
if day_of_month < 1 or day_of_month > days_per_month:
raise ValueError('Day of month value out of bounds.')
day_of_year = day_of_month
for past_month in range(1, month):
day_of_year += self._GetDaysPerMonth(year, past_month)
return day_of_year |
Retrieves the number of days in a month of a specific year.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
Returns:
int: number of days in the month.
Raises:
ValueError: if the month value is out of bounds.
def _GetDaysPerMonth(self, year, month):
"""Retrieves the number of days in a month of a specific year.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
Returns:
int: number of days in the month.
Raises:
ValueError: if the month value is out of bounds.
"""
if month not in range(1, 13):
raise ValueError('Month value out of bounds.')
days_per_month = self._DAYS_PER_MONTH[month - 1]
if month == 2 and self._IsLeapYear(year):
days_per_month += 1
return days_per_month |
Retrieves the number of days in a century.
Args:
year (int): year in the century e.g. 1970.
Returns:
int: number of (remaining) days in the century.
Raises:
ValueError: if the year value is out of bounds.
def _GetNumberOfDaysInCentury(self, year):
"""Retrieves the number of days in a century.
Args:
year (int): year in the century e.g. 1970.
Returns:
int: number of (remaining) days in the century.
Raises:
ValueError: if the year value is out of bounds.
"""
if year < 0:
raise ValueError('Year value out of bounds.')
year, _ = divmod(year, 100)
if self._IsLeapYear(year):
return 36525
return 36524 |
Retrieves the number of seconds from the date and time elements.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
day_of_month (int): day of the month, where 1 represents the first day.
hours (int): hours.
minutes (int): minutes.
seconds (int): seconds.
Returns:
int: number of seconds since January 1, 1970 00:00:00 or None if year,
month or day of month are not set.
Raises:
ValueError: if the time elements are invalid.
def _GetNumberOfSecondsFromElements(
self, year, month, day_of_month, hours, minutes, seconds):
"""Retrieves the number of seconds from the date and time elements.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
day_of_month (int): day of the month, where 1 represents the first day.
hours (int): hours.
minutes (int): minutes.
seconds (int): seconds.
Returns:
int: number of seconds since January 1, 1970 00:00:00 or None if year,
month or day of month are not set.
Raises:
ValueError: if the time elements are invalid.
"""
if not year or not month or not day_of_month:
return None
# calendar.timegm does not sanity check the time elements.
if hours is None:
hours = 0
elif hours not in range(0, 24):
raise ValueError('Hours value: {0!s} out of bounds.'.format(hours))
if minutes is None:
minutes = 0
elif minutes not in range(0, 60):
raise ValueError('Minutes value: {0!s} out of bounds.'.format(minutes))
# TODO: support a leap second?
if seconds is None:
seconds = 0
elif seconds not in range(0, 60):
raise ValueError('Seconds value: {0!s} out of bounds.'.format(seconds))
# Note that calendar.timegm() does not raise when date is: 2013-02-29.
days_per_month = self._GetDaysPerMonth(year, month)
if day_of_month < 1 or day_of_month > days_per_month:
raise ValueError('Day of month value out of bounds.')
# calendar.timegm requires the time tuple to contain at least
# 6 integer values.
time_elements_tuple = (year, month, day_of_month, hours, minutes, seconds)
number_of_seconds = calendar.timegm(time_elements_tuple)
return int(number_of_seconds) |
Determines time values.
Args:
number_of_seconds (int|decimal.Decimal): number of seconds.
Returns:
tuple[int, int, int, int]: days, hours, minutes, seconds.
def _GetTimeValues(self, number_of_seconds):
"""Determines time values.
Args:
number_of_seconds (int|decimal.Decimal): number of seconds.
Returns:
tuple[int, int, int, int]: days, hours, minutes, seconds.
"""
number_of_seconds = int(number_of_seconds)
number_of_minutes, seconds = divmod(number_of_seconds, 60)
number_of_hours, minutes = divmod(number_of_minutes, 60)
number_of_days, hours = divmod(number_of_hours, 24)
return number_of_days, hours, minutes, seconds |
Copies the date time value to a stat timestamp tuple.
Returns:
tuple[int, int]: a POSIX timestamp in seconds and the remainder in
100 nano seconds or (None, None) on error.
def CopyToStatTimeTuple(self):
"""Copies the date time value to a stat timestamp tuple.
Returns:
tuple[int, int]: a POSIX timestamp in seconds and the remainder in
100 nano seconds or (None, None) on error.
"""
normalized_timestamp = self._GetNormalizedTimestamp()
if normalized_timestamp is None:
return None, None
if self._precision in (
definitions.PRECISION_1_NANOSECOND,
definitions.PRECISION_100_NANOSECONDS,
definitions.PRECISION_1_MICROSECOND,
definitions.PRECISION_1_MILLISECOND,
definitions.PRECISION_100_MILLISECONDS):
remainder = int((normalized_timestamp % 1) * self._100NS_PER_SECOND)
return int(normalized_timestamp), remainder
return int(normalized_timestamp), None |
Copies the date time value to an ISO 8601 date and time string.
Returns:
str: date and time value formatted as an ISO 8601 date and time string or
None if the timestamp cannot be copied to a date and time string.
def CopyToDateTimeStringISO8601(self):
"""Copies the date time value to an ISO 8601 date and time string.
Returns:
str: date and time value formatted as an ISO 8601 date and time string or
None if the timestamp cannot be copied to a date and time string.
"""
date_time_string = self.CopyToDateTimeString()
if date_time_string:
date_time_string = date_time_string.replace(' ', 'T')
date_time_string = '{0:s}Z'.format(date_time_string)
return date_time_string |
Retrieves the date represented by the date and time values.
Returns:
tuple[int, int, int]: year, month, day of month or (None, None, None)
if the date and time values do not represent a date.
def GetDate(self):
"""Retrieves the date represented by the date and time values.
Returns:
tuple[int, int, int]: year, month, day of month or (None, None, None)
if the date and time values do not represent a date.
"""
normalized_timestamp = self._GetNormalizedTimestamp()
if normalized_timestamp is None:
return None, None, None
number_of_days, _, _, _ = self._GetTimeValues(normalized_timestamp)
try:
return self._GetDateValuesWithEpoch(
number_of_days, self._EPOCH_NORMALIZED_TIME)
except ValueError:
return None, None, None |
Retrieves a timestamp that is compatible with plaso.
Returns:
int: a POSIX timestamp in microseconds or None if no timestamp is
available.
def GetPlasoTimestamp(self):
"""Retrieves a timestamp that is compatible with plaso.
Returns:
int: a POSIX timestamp in microseconds or None if no timestamp is
available.
"""
normalized_timestamp = self._GetNormalizedTimestamp()
if normalized_timestamp is None:
return None
normalized_timestamp *= definitions.MICROSECONDS_PER_SECOND
normalized_timestamp = normalized_timestamp.quantize(
1, rounding=decimal.ROUND_HALF_UP)
return int(normalized_timestamp) |
Retrieves the time of day represented by the date and time values.
Returns:
tuple[int, int, int]: hours, minutes, seconds or (None, None, None)
if the date and time values do not represent a time of day.
def GetTimeOfDay(self):
"""Retrieves the time of day represented by the date and time values.
Returns:
tuple[int, int, int]: hours, minutes, seconds or (None, None, None)
if the date and time values do not represent a time of day.
"""
normalized_timestamp = self._GetNormalizedTimestamp()
if normalized_timestamp is None:
return None, None, None
_, hours, minutes, seconds = self._GetTimeValues(normalized_timestamp)
return hours, minutes, seconds |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if (self._timestamp is not None and self._timestamp >= 0 and
self._timestamp <= self._UINT32_MAX):
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) - self._HFS_TO_POSIX_BASE)
return self._normalized_timestamp |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._number_of_seconds is not None:
self._normalized_timestamp = (
decimal.Decimal(self._microseconds) /
definitions.MICROSECONDS_PER_SECOND)
self._normalized_timestamp += decimal.Decimal(self._number_of_seconds)
return self._normalized_timestamp |
Copies a fake timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
def CopyFromDateTimeString(self, time_string):
"""Copies a fake timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
"""
date_time_values = self._CopyDateTimeFromString(time_string)
year = date_time_values.get('year', 0)
month = date_time_values.get('month', 0)
day_of_month = date_time_values.get('day_of_month', 0)
hours = date_time_values.get('hours', 0)
minutes = date_time_values.get('minutes', 0)
seconds = date_time_values.get('seconds', 0)
self._normalized_timestamp = None
self._number_of_seconds = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
self._microseconds = date_time_values.get('microseconds', None)
self.is_local_time = False |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._number_of_seconds is not None:
self._normalized_timestamp = (
decimal.Decimal(self.deciseconds) /
definitions.DECISECONDS_PER_SECOND)
self._normalized_timestamp += decimal.Decimal(self._number_of_seconds)
return self._normalized_timestamp |
Copies the RFC2579 date-time to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#" or
None if the number of seconds is missing.
def CopyToDateTimeString(self):
"""Copies the RFC2579 date-time to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#" or
None if the number of seconds is missing.
"""
if self._number_of_seconds is None:
return None
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:01d}'.format(
self.year, self.month, self.day_of_month, self.hours, self.minutes,
self.seconds, self.deciseconds) |
Ensures we have a connection to the SMS gateway. Returns whether or not a new connection was required (True or False).
def open(self):
"""
Ensures we have a connection to the SMS gateway. Returns whether or not a new connection was required (True or False).
"""
if self.connection:
# Nothing to do if the connection is already open.
return False
self.connection = self._get_twilio_client()
return True |
A helper method that does the actual sending.
def _send(self, email_message):
"""A helper method that does the actual sending."""
if not email_message.recipients():
return False
from_email = email_message.from_email
recipients = email_message.recipients()
try:
self.connection.messages.create(
to=recipients,
from_=from_email,
body=email_message.body
)
except Exception:
if not self.fail_silently:
raise
return False
return True |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._number_of_seconds is not None and self._number_of_seconds >= 0:
self._normalized_timestamp = (
decimal.Decimal(self._number_of_seconds) +
self._FAT_DATE_TO_POSIX_BASE)
return self._normalized_timestamp |
Retrieves the number of seconds from a FAT date time.
Args:
fat_date_time (int): FAT date time.
Returns:
int: number of seconds since January 1, 1980 00:00:00.
Raises:
ValueError: if the month, day of month, hours, minutes or seconds
value is out of bounds.
def _GetNumberOfSeconds(self, fat_date_time):
"""Retrieves the number of seconds from a FAT date time.
Args:
fat_date_time (int): FAT date time.
Returns:
int: number of seconds since January 1, 1980 00:00:00.
Raises:
ValueError: if the month, day of month, hours, minutes or seconds
value is out of bounds.
"""
day_of_month = (fat_date_time & 0x1f)
month = ((fat_date_time >> 5) & 0x0f)
year = (fat_date_time >> 9) & 0x7f
days_per_month = self._GetDaysPerMonth(year, month)
if day_of_month < 1 or day_of_month > days_per_month:
raise ValueError('Day of month value out of bounds.')
number_of_days = self._GetDayOfYear(1980 + year, month, day_of_month)
number_of_days -= 1
for past_year in range(0, year):
number_of_days += self._GetNumberOfDaysInYear(past_year)
fat_date_time >>= 16
seconds = (fat_date_time & 0x1f) * 2
minutes = (fat_date_time >> 5) & 0x3f
hours = (fat_date_time >> 11) & 0x1f
if hours not in range(0, 24):
raise ValueError('Hours value out of bounds.')
if minutes not in range(0, 60):
raise ValueError('Minutes value out of bounds.')
if seconds not in range(0, 60):
raise ValueError('Seconds value out of bounds.')
number_of_seconds = (((hours * 60) + minutes) * 60) + seconds
number_of_seconds += number_of_days * definitions.SECONDS_PER_DAY
return number_of_seconds |
Load an sms backend and return an instance of it.
If backend is None (default) settings.SMS_BACKEND is used.
Both fail_silently and other keyword arguments are used in the
constructor of the backend.
https://github.com/django/django/blob/master/django/core/mail/__init__.py#L28
def get_sms_connection(backend=None, fail_silently=False, **kwds):
"""Load an sms backend and return an instance of it.
If backend is None (default) settings.SMS_BACKEND is used.
Both fail_silently and other keyword arguments are used in the
constructor of the backend.
https://github.com/django/django/blob/master/django/core/mail/__init__.py#L28
"""
klass = import_string(backend or settings.SMS_BACKEND)
return klass(fail_silently=fail_silently, **kwds) |
Easy wrapper for sending a single message to a recipient list. All members
of the recipient list will see the other recipients in the 'To' field.
If auth_user is None, the EMAIL_HOST_USER setting is used.
If auth_password is None, the EMAIL_HOST_PASSWORD setting is used.
Note: The API for this method is frozen. New code wanting to extend the
functionality should use the EmailMessage class directly.
https://github.com/django/django/blob/master/django/core/mail/__init__.py#L40
def send_sms(message, from_number, recipient_list, fail_silently=False, auth_user=None, auth_password=None, connection=None):
"""
Easy wrapper for sending a single message to a recipient list. All members
of the recipient list will see the other recipients in the 'To' field.
If auth_user is None, the EMAIL_HOST_USER setting is used.
If auth_password is None, the EMAIL_HOST_PASSWORD setting is used.
Note: The API for this method is frozen. New code wanting to extend the
functionality should use the EmailMessage class directly.
https://github.com/django/django/blob/master/django/core/mail/__init__.py#L40
"""
connection = connection or get_sms_connection(username=auth_user, password=auth_password, fail_silently=fail_silently)
mail = SMSMessage(message, from_number, recipient_list, connection=connection)
return mail.send() |
Given a datatuple of (subject, message, from_email, recipient_list), sends
each message to each recipient list. Returns the number of emails sent.
If from_email is None, the DEFAULT_FROM_EMAIL setting is used.
If auth_user and auth_password are set, they're used to log in.
If auth_user is None, the EMAIL_HOST_USER setting is used.
If auth_password is None, the EMAIL_HOST_PASSWORD setting is used.
Note: The API for this method is frozen. New code wanting to extend the
functionality should use the EmailMessage class directly.
https://github.com/django/django/blob/master/django/core/mail/__init__.py#L64
def send_mass_sms(datatuple, fail_silently=False, auth_user=None, auth_password=None, connection=None):
"""
Given a datatuple of (subject, message, from_email, recipient_list), sends
each message to each recipient list. Returns the number of emails sent.
If from_email is None, the DEFAULT_FROM_EMAIL setting is used.
If auth_user and auth_password are set, they're used to log in.
If auth_user is None, the EMAIL_HOST_USER setting is used.
If auth_password is None, the EMAIL_HOST_PASSWORD setting is used.
Note: The API for this method is frozen. New code wanting to extend the
functionality should use the EmailMessage class directly.
https://github.com/django/django/blob/master/django/core/mail/__init__.py#L64
"""
import smsish.sms.backends.rq
if isinstance(connection, smsish.sms.backends.rq.SMSBackend):
raise NotImplementedError
connection = connection or get_sms_connection(username=auth_user, password=auth_password, fail_silently=fail_silently)
messages = [SMSMessage(message, from_number, recipient, connection=connection) for message, from_number, recipient in datatuple]
return connection.send_messages(messages) |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if (self._timestamp is not None and self._timestamp >= 0 and
self._timestamp <= self._UINT64_MAX):
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) / self._100NS_PER_SECOND)
self._normalized_timestamp -= self._FILETIME_TO_POSIX_BASE
return self._normalized_timestamp |
Copies the FILETIME timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#######" or
None if the timestamp is missing or invalid.
def CopyToDateTimeString(self):
"""Copies the FILETIME timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#######" or
None if the timestamp is missing or invalid.
"""
if (self._timestamp is None or self._timestamp < 0 or
self._timestamp > self._UINT64_MAX):
return None
timestamp, remainder = divmod(self._timestamp, self._100NS_PER_SECOND)
number_of_days, hours, minutes, seconds = self._GetTimeValues(timestamp)
year, month, day_of_month = self._GetDateValuesWithEpoch(
number_of_days, self._EPOCH)
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:07d}'.format(
year, month, day_of_month, hours, minutes, seconds, remainder) |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second
used for increased precision, or None if the normalized timestamp
cannot be determined.
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second
used for increased precision, or None if the normalized timestamp
cannot be determined.
"""
if self._normalized_timestamp is None:
if (self._timestamp is not None and self._timestamp >= 0 and
self._timestamp <= self._UINT60_MAX):
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) / self._100NS_PER_SECOND)
self._normalized_timestamp -= self._UUID_TO_POSIX_BASE
return self._normalized_timestamp |
Copies the time elements and fraction of second to a string.
Args:
time_elements_tuple (tuple[int, int, int, int, int, int]):
time elements, contains year, month, day of month, hours, minutes and
seconds.
fraction_of_second (decimal.Decimal): fraction of second, which must be a
value between 0.0 and 1.0.
Returns:
str: date and time value formatted as:
YYYY-MM-DD hh:mm:ss
Raises:
ValueError: if the fraction of second is out of bounds.
def CopyToDateTimeString(cls, time_elements_tuple, fraction_of_second):
"""Copies the time elements and fraction of second to a string.
Args:
time_elements_tuple (tuple[int, int, int, int, int, int]):
time elements, contains year, month, day of month, hours, minutes and
seconds.
fraction_of_second (decimal.Decimal): fraction of second, which must be a
value between 0.0 and 1.0.
Returns:
str: date and time value formatted as:
YYYY-MM-DD hh:mm:ss
Raises:
ValueError: if the fraction of second is out of bounds.
"""
if fraction_of_second < 0.0 or fraction_of_second >= 1.0:
raise ValueError('Fraction of second value: {0:f} out of bounds.'.format(
fraction_of_second))
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}'.format(
time_elements_tuple[0], time_elements_tuple[1], time_elements_tuple[2],
time_elements_tuple[3], time_elements_tuple[4], time_elements_tuple[5]) |
Copies the number of microseconds to a fraction of second value.
Args:
microseconds (int): number of microseconds.
Returns:
decimal.Decimal: fraction of second, which must be a value between 0.0 and
1.0.
Raises:
ValueError: if the number of microseconds is out of bounds.
def CopyMicrosecondsToFractionOfSecond(cls, microseconds):
"""Copies the number of microseconds to a fraction of second value.
Args:
microseconds (int): number of microseconds.
Returns:
decimal.Decimal: fraction of second, which must be a value between 0.0 and
1.0.
Raises:
ValueError: if the number of microseconds is out of bounds.
"""
if microseconds < 0 or microseconds >= definitions.MICROSECONDS_PER_SECOND:
raise ValueError(
'Number of microseconds value: {0:d} out of bounds.'.format(
microseconds))
milliseconds, _ = divmod(
microseconds, definitions.MICROSECONDS_PER_MILLISECOND)
return decimal.Decimal(milliseconds) / definitions.MILLISECONDS_PER_SECOND |
Copies the time elements and fraction of second to a string.
Args:
time_elements_tuple (tuple[int, int, int, int, int, int]):
time elements, contains year, month, day of month, hours, minutes and
seconds.
fraction_of_second (decimal.Decimal): fraction of second, which must be a
value between 0.0 and 1.0.
Returns:
str: date and time value formatted as:
YYYY-MM-DD hh:mm:ss.###
Raises:
ValueError: if the fraction of second is out of bounds.
def CopyToDateTimeString(cls, time_elements_tuple, fraction_of_second):
"""Copies the time elements and fraction of second to a string.
Args:
time_elements_tuple (tuple[int, int, int, int, int, int]):
time elements, contains year, month, day of month, hours, minutes and
seconds.
fraction_of_second (decimal.Decimal): fraction of second, which must be a
value between 0.0 and 1.0.
Returns:
str: date and time value formatted as:
YYYY-MM-DD hh:mm:ss.###
Raises:
ValueError: if the fraction of second is out of bounds.
"""
if fraction_of_second < 0.0 or fraction_of_second >= 1.0:
raise ValueError('Fraction of second value: {0:f} out of bounds.'.format(
fraction_of_second))
milliseconds = int(fraction_of_second * definitions.MILLISECONDS_PER_SECOND)
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:03d}'.format(
time_elements_tuple[0], time_elements_tuple[1], time_elements_tuple[2],
time_elements_tuple[3], time_elements_tuple[4], time_elements_tuple[5],
milliseconds) |
Copies the number of microseconds to a fraction of second value.
Args:
microseconds (int): number of microseconds.
Returns:
decimal.Decimal: fraction of second, which must be a value between 0.0 and
1.0.
Raises:
ValueError: if the number of microseconds is out of bounds.
def CopyMicrosecondsToFractionOfSecond(cls, microseconds):
"""Copies the number of microseconds to a fraction of second value.
Args:
microseconds (int): number of microseconds.
Returns:
decimal.Decimal: fraction of second, which must be a value between 0.0 and
1.0.
Raises:
ValueError: if the number of microseconds is out of bounds.
"""
if microseconds < 0 or microseconds >= definitions.MICROSECONDS_PER_SECOND:
raise ValueError(
'Number of microseconds value: {0:d} out of bounds.'.format(
microseconds))
return decimal.Decimal(microseconds) / definitions.MICROSECONDS_PER_SECOND |
Copies the time elements and fraction of second to a string.
Args:
time_elements_tuple (tuple[int, int, int, int, int, int]):
time elements, contains year, month, day of month, hours, minutes and
seconds.
fraction_of_second (decimal.Decimal): fraction of second, which must be a
value between 0.0 and 1.0.
Returns:
str: date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######
Raises:
ValueError: if the fraction of second is out of bounds.
def CopyToDateTimeString(cls, time_elements_tuple, fraction_of_second):
"""Copies the time elements and fraction of second to a string.
Args:
time_elements_tuple (tuple[int, int, int, int, int, int]):
time elements, contains year, month, day of month, hours, minutes and
seconds.
fraction_of_second (decimal.Decimal): fraction of second, which must be a
value between 0.0 and 1.0.
Returns:
str: date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######
Raises:
ValueError: if the fraction of second is out of bounds.
"""
if fraction_of_second < 0.0 or fraction_of_second >= 1.0:
raise ValueError('Fraction of second value: {0:f} out of bounds.'.format(
fraction_of_second))
microseconds = int(fraction_of_second * definitions.MICROSECONDS_PER_SECOND)
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:06d}'.format(
time_elements_tuple[0], time_elements_tuple[1], time_elements_tuple[2],
time_elements_tuple[3], time_elements_tuple[4], time_elements_tuple[5],
microseconds) |
Creates a precision helper.
Args:
precision (str): precision of the date and time value, which should
be one of the PRECISION_VALUES in definitions.
Returns:
class: date time precision helper class.
Raises:
ValueError: if the precision value is unsupported.
def CreatePrecisionHelper(cls, precision):
"""Creates a precision helper.
Args:
precision (str): precision of the date and time value, which should
be one of the PRECISION_VALUES in definitions.
Returns:
class: date time precision helper class.
Raises:
ValueError: if the precision value is unsupported.
"""
precision_helper_class = cls._PRECISION_CLASSES.get(precision, None)
if not precision_helper_class:
raise ValueError('Unsupported precision: {0!s}'.format(precision))
return precision_helper_class |
Copies a APFS timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
Raises:
ValueError: if the date and time value is not supported.
def CopyFromDateTimeString(self, time_string):
"""Copies a APFS timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
Raises:
ValueError: if the date and time value is not supported.
"""
super(APFSTime, self)._CopyFromDateTimeString(time_string)
if (self._timestamp is None or self._timestamp < self._INT64_MIN or
self._timestamp > self._INT64_MAX):
raise ValueError('Date time value not supported.') |
Copies the APFS timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#########" or
None if the timestamp is missing or invalid.
def CopyToDateTimeString(self):
"""Copies the APFS timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#########" or
None if the timestamp is missing or invalid.
"""
if (self._timestamp is None or self._timestamp < self._INT64_MIN or
self._timestamp > self._INT64_MAX):
return None
return super(APFSTime, self)._CopyToDateTimeString() |
Copies the Cocoa timestamp to a date and time string.
Returns:
str: date and time value formatted as: YYYY-MM-DD hh:mm:ss.###### or
None if the timestamp cannot be copied to a date and time string.
def CopyToDateTimeString(self):
"""Copies the Cocoa timestamp to a date and time string.
Returns:
str: date and time value formatted as: YYYY-MM-DD hh:mm:ss.###### or
None if the timestamp cannot be copied to a date and time string.
"""
if self._timestamp is None:
return None
number_of_days, hours, minutes, seconds = self._GetTimeValues(
int(self._timestamp))
year, month, day_of_month = self._GetDateValuesWithEpoch(
number_of_days, self._EPOCH)
microseconds = int(
(self._timestamp % 1) * definitions.MICROSECONDS_PER_SECOND)
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:06d}'.format(
year, month, day_of_month, hours, minutes, seconds, microseconds) |
Send an SMSMessage instance using a connection given by the specified `backend`.
def send_sms_message(sms_message, backend=None, fail_silently=False):
"""
Send an SMSMessage instance using a connection given by the specified `backend`.
"""
with get_sms_connection(backend=backend, fail_silently=fail_silently) as connection:
result = connection.send_messages([sms_message])
return result |
Receives a list of SMSMessage instances and returns a list of RQ `Job` instances.
def send_messages(self, sms_messages):
"""
Receives a list of SMSMessage instances and returns a list of RQ `Job` instances.
"""
results = []
for message in sms_messages:
try:
assert message.connection is None
except AssertionError:
if not self.fail_silently:
raise
backend = self.backend
fail_silently = self.fail_silently
result = django_rq.enqueue(self._send, message, backend=backend, fail_silently=fail_silently)
results.append(result)
return results |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if (self._timestamp is not None and self._timestamp >= self._INT64_MIN and
self._timestamp <= self._INT64_MAX):
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) /
definitions.MILLISECONDS_PER_SECOND)
return self._normalized_timestamp |
Copies the POSIX timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.######" or
None if the timestamp is missing.
def CopyToDateTimeString(self):
"""Copies the POSIX timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.######" or
None if the timestamp is missing.
"""
if (self._timestamp is None or self._timestamp < self._INT64_MIN or
self._timestamp > self._INT64_MAX):
return None
return super(JavaTime, self).CopyToDateTimeString() |
Inspired by:
- https://github.com/torchbox/wagtail/blob/master/wagtail/wagtailimages/rich_text.py
- https://github.com/torchbox/wagtail/blob/master/wagtail/wagtailimages/shortcuts.py
- https://github.com/torchbox/wagtail/blob/master/wagtail/wagtailimages/formats.py
def Image(props):
"""
Inspired by:
- https://github.com/torchbox/wagtail/blob/master/wagtail/wagtailimages/rich_text.py
- https://github.com/torchbox/wagtail/blob/master/wagtail/wagtailimages/shortcuts.py
- https://github.com/torchbox/wagtail/blob/master/wagtail/wagtailimages/formats.py
"""
image_model = get_image_model()
alignment = props.get('alignment', 'left')
alt_text = props.get('altText', '')
try:
image = image_model.objects.get(id=props['id'])
except image_model.DoesNotExist:
return DOM.create_element('img', {'alt': alt_text})
image_format = get_image_format(alignment)
rendition = get_rendition_or_not_found(image, image_format.filter_spec)
return DOM.create_element('img', dict(rendition.attrs_dict, **{
'class': image_format.classnames,
'src': rendition.url,
'alt': alt_text,
})) |
Copies a date and time from an ISO 8601 date and time string.
Args:
time_string (str): time value formatted as:
hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The fraction of second and
time zone offset are optional.
Returns:
tuple[int, int, int, int, int]: hours, minutes, seconds, microseconds,
time zone offset in minutes.
Raises:
ValueError: if the time string is invalid or not supported.
def _CopyDateTimeFromStringISO8601(self, time_string):
"""Copies a date and time from an ISO 8601 date and time string.
Args:
time_string (str): time value formatted as:
hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The fraction of second and
time zone offset are optional.
Returns:
tuple[int, int, int, int, int]: hours, minutes, seconds, microseconds,
time zone offset in minutes.
Raises:
ValueError: if the time string is invalid or not supported.
"""
if not time_string:
raise ValueError('Invalid time string.')
time_string_length = len(time_string)
year, month, day_of_month = self._CopyDateFromString(time_string)
if time_string_length <= 10:
return {
'year': year,
'month': month,
'day_of_month': day_of_month}
# If a time of day is specified the time string it should at least
# contain 'YYYY-MM-DDThh'.
if time_string[10] != 'T':
raise ValueError(
'Invalid time string - missing as date and time separator.')
hours, minutes, seconds, microseconds, time_zone_offset = (
self._CopyTimeFromStringISO8601(time_string[11:]))
if time_zone_offset:
year, month, day_of_month, hours, minutes = self._AdjustForTimeZoneOffset(
year, month, day_of_month, hours, minutes, time_zone_offset)
date_time_values = {
'year': year,
'month': month,
'day_of_month': day_of_month,
'hours': hours,
'minutes': minutes,
'seconds': seconds}
if microseconds is not None:
date_time_values['microseconds'] = microseconds
return date_time_values |
Copies time elements from date and time values.
Args:
date_time_values (dict[str, int]): date and time values, such as year,
month, day of month, hours, minutes, seconds, microseconds.
def _CopyFromDateTimeValues(self, date_time_values):
"""Copies time elements from date and time values.
Args:
date_time_values (dict[str, int]): date and time values, such as year,
month, day of month, hours, minutes, seconds, microseconds.
"""
year = date_time_values.get('year', 0)
month = date_time_values.get('month', 0)
day_of_month = date_time_values.get('day_of_month', 0)
hours = date_time_values.get('hours', 0)
minutes = date_time_values.get('minutes', 0)
seconds = date_time_values.get('seconds', 0)
self._normalized_timestamp = None
self._number_of_seconds = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
self._time_elements_tuple = (
year, month, day_of_month, hours, minutes, seconds)
self.is_local_time = False |
Copies a time from an ISO 8601 date and time string.
Args:
time_string (str): time value formatted as:
hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The faction of second and
time zone offset are optional.
Returns:
tuple[int, int, int, int, int]: hours, minutes, seconds, microseconds,
time zone offset in minutes.
Raises:
ValueError: if the time string is invalid or not supported.
def _CopyTimeFromStringISO8601(self, time_string):
"""Copies a time from an ISO 8601 date and time string.
Args:
time_string (str): time value formatted as:
hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The faction of second and
time zone offset are optional.
Returns:
tuple[int, int, int, int, int]: hours, minutes, seconds, microseconds,
time zone offset in minutes.
Raises:
ValueError: if the time string is invalid or not supported.
"""
if time_string.endswith('Z'):
time_string = time_string[:-1]
time_string_length = len(time_string)
# The time string should at least contain 'hh'.
if time_string_length < 2:
raise ValueError('Time string too short.')
try:
hours = int(time_string[0:2], 10)
except ValueError:
raise ValueError('Unable to parse hours.')
if hours not in range(0, 24):
raise ValueError('Hours value: {0:d} out of bounds.'.format(hours))
minutes = None
seconds = None
microseconds = None
time_zone_offset = None
time_string_index = 2
# Minutes are either specified as 'hhmm', 'hh:mm' or as a fractional part
# 'hh[.,]###'.
if (time_string_index + 1 < time_string_length and
time_string[time_string_index] not in ('.', ',')):
if time_string[time_string_index] == ':':
time_string_index += 1
if time_string_index + 2 > time_string_length:
raise ValueError('Time string too short.')
try:
minutes = time_string[time_string_index:time_string_index + 2]
minutes = int(minutes, 10)
except ValueError:
raise ValueError('Unable to parse minutes.')
time_string_index += 2
# Seconds are either specified as 'hhmmss', 'hh:mm:ss' or as a fractional
# part 'hh:mm[.,]###' or 'hhmm[.,]###'.
if (time_string_index + 1 < time_string_length and
time_string[time_string_index] not in ('.', ',')):
if time_string[time_string_index] == ':':
time_string_index += 1
if time_string_index + 2 > time_string_length:
raise ValueError('Time string too short.')
try:
seconds = time_string[time_string_index:time_string_index + 2]
seconds = int(seconds, 10)
except ValueError:
raise ValueError('Unable to parse day of seconds.')
time_string_index += 2
time_zone_string_index = time_string_index
while time_zone_string_index < time_string_length:
if time_string[time_zone_string_index] in ('+', '-'):
break
time_zone_string_index += 1
# The calculations that follow rely on the time zone string index
# to point beyond the string in case no time zone offset was defined.
if time_zone_string_index == time_string_length - 1:
time_zone_string_index += 1
if (time_string_length > time_string_index and
time_string[time_string_index] in ('.', ',')):
time_string_index += 1
time_fraction_length = time_zone_string_index - time_string_index
try:
time_fraction = time_string[time_string_index:time_zone_string_index]
time_fraction = int(time_fraction, 10)
time_fraction = (
decimal.Decimal(time_fraction) /
decimal.Decimal(10 ** time_fraction_length))
except ValueError:
raise ValueError('Unable to parse time fraction.')
if minutes is None:
time_fraction *= 60
minutes = int(time_fraction)
time_fraction -= minutes
if seconds is None:
time_fraction *= 60
seconds = int(time_fraction)
time_fraction -= seconds
time_fraction *= definitions.MICROSECONDS_PER_SECOND
microseconds = int(time_fraction)
if minutes is not None and minutes not in range(0, 60):
raise ValueError('Minutes value: {0:d} out of bounds.'.format(minutes))
# TODO: support a leap second?
if seconds is not None and seconds not in range(0, 60):
raise ValueError('Seconds value: {0:d} out of bounds.'.format(seconds))
if time_zone_string_index < time_string_length:
if (time_string_length - time_zone_string_index != 6 or
time_string[time_zone_string_index + 3] != ':'):
raise ValueError('Invalid time string.')
try:
hours_from_utc = int(time_string[
time_zone_string_index + 1:time_zone_string_index + 3])
except ValueError:
raise ValueError('Unable to parse time zone hours offset.')
if hours_from_utc not in range(0, 15):
raise ValueError('Time zone hours offset value out of bounds.')
try:
minutes_from_utc = int(time_string[
time_zone_string_index + 4:time_zone_string_index + 6])
except ValueError:
raise ValueError('Unable to parse time zone minutes offset.')
if minutes_from_utc not in range(0, 60):
raise ValueError('Time zone minutes offset value out of bounds.')
# pylint: disable=invalid-unary-operand-type
time_zone_offset = (hours_from_utc * 60) + minutes_from_utc
# Note that when the sign of the time zone offset is negative
# the difference needs to be added. We do so by flipping the sign.
if time_string[time_zone_string_index] != '-':
time_zone_offset = -time_zone_offset
return hours, minutes, seconds, microseconds, time_zone_offset |
Copies time elements from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
def CopyFromDateTimeString(self, time_string):
"""Copies time elements from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
"""
date_time_values = self._CopyDateTimeFromString(time_string)
self._CopyFromDateTimeValues(date_time_values) |
Copies time elements from an ISO 8601 date and time string.
Currently not supported:
* Duration notation: "P..."
* Week notation "2016-W33"
* Date with week number notation "2016-W33-3"
* Date without year notation "--08-17"
* Ordinal date notation "2016-230"
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DDThh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
Raises:
ValueError: if the time string is invalid or not supported.
def CopyFromStringISO8601(self, time_string):
"""Copies time elements from an ISO 8601 date and time string.
Currently not supported:
* Duration notation: "P..."
* Week notation "2016-W33"
* Date with week number notation "2016-W33-3"
* Date without year notation "--08-17"
* Ordinal date notation "2016-230"
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DDThh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
Raises:
ValueError: if the time string is invalid or not supported.
"""
date_time_values = self._CopyDateTimeFromStringISO8601(time_string)
self._CopyFromDateTimeValues(date_time_values) |
Copies time elements from string-based time elements tuple.
Args:
time_elements_tuple (Optional[tuple[str, str, str, str, str, str]]):
time elements, contains year, month, day of month, hours, minutes and
seconds.
Raises:
ValueError: if the time elements tuple is invalid.
def CopyFromStringTuple(self, time_elements_tuple):
"""Copies time elements from string-based time elements tuple.
Args:
time_elements_tuple (Optional[tuple[str, str, str, str, str, str]]):
time elements, contains year, month, day of month, hours, minutes and
seconds.
Raises:
ValueError: if the time elements tuple is invalid.
"""
if len(time_elements_tuple) < 6:
raise ValueError((
'Invalid time elements tuple at least 6 elements required,'
'got: {0:d}').format(len(time_elements_tuple)))
try:
year = int(time_elements_tuple[0], 10)
except (TypeError, ValueError):
raise ValueError('Invalid year value: {0!s}'.format(
time_elements_tuple[0]))
try:
month = int(time_elements_tuple[1], 10)
except (TypeError, ValueError):
raise ValueError('Invalid month value: {0!s}'.format(
time_elements_tuple[1]))
try:
day_of_month = int(time_elements_tuple[2], 10)
except (TypeError, ValueError):
raise ValueError('Invalid day of month value: {0!s}'.format(
time_elements_tuple[2]))
try:
hours = int(time_elements_tuple[3], 10)
except (TypeError, ValueError):
raise ValueError('Invalid hours value: {0!s}'.format(
time_elements_tuple[3]))
try:
minutes = int(time_elements_tuple[4], 10)
except (TypeError, ValueError):
raise ValueError('Invalid minutes value: {0!s}'.format(
time_elements_tuple[4]))
try:
seconds = int(time_elements_tuple[5], 10)
except (TypeError, ValueError):
raise ValueError('Invalid seconds value: {0!s}'.format(
time_elements_tuple[5]))
self._normalized_timestamp = None
self._number_of_seconds = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
self._time_elements_tuple = (
year, month, day_of_month, hours, minutes, seconds) |
Copies the time elements to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss" or None
if time elements are missing.
def CopyToDateTimeString(self):
"""Copies the time elements to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss" or None
if time elements are missing.
"""
if self._number_of_seconds is None:
return None
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}'.format(
self._time_elements_tuple[0], self._time_elements_tuple[1],
self._time_elements_tuple[2], self._time_elements_tuple[3],
self._time_elements_tuple[4], self._time_elements_tuple[5]) |
Copies time elements from date and time values.
Args:
date_time_values (dict[str, int]): date and time values, such as year,
month, day of month, hours, minutes, seconds, microseconds.
Raises:
ValueError: if no helper can be created for the current precision.
def _CopyFromDateTimeValues(self, date_time_values):
"""Copies time elements from date and time values.
Args:
date_time_values (dict[str, int]): date and time values, such as year,
month, day of month, hours, minutes, seconds, microseconds.
Raises:
ValueError: if no helper can be created for the current precision.
"""
year = date_time_values.get('year', 0)
month = date_time_values.get('month', 0)
day_of_month = date_time_values.get('day_of_month', 0)
hours = date_time_values.get('hours', 0)
minutes = date_time_values.get('minutes', 0)
seconds = date_time_values.get('seconds', 0)
microseconds = date_time_values.get('microseconds', 0)
precision_helper = precisions.PrecisionHelperFactory.CreatePrecisionHelper(
self._precision)
fraction_of_second = precision_helper.CopyMicrosecondsToFractionOfSecond(
microseconds)
self._normalized_timestamp = None
self._number_of_seconds = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
self._time_elements_tuple = (
year, month, day_of_month, hours, minutes, seconds)
self.fraction_of_second = fraction_of_second
self.is_local_time = False |
Copies time elements from string-based time elements tuple.
Args:
time_elements_tuple (Optional[tuple[str, str, str, str, str, str, str]]):
time elements, contains year, month, day of month, hours, minutes,
seconds and fraction of seconds.
Raises:
ValueError: if the time elements tuple is invalid.
def CopyFromStringTuple(self, time_elements_tuple):
"""Copies time elements from string-based time elements tuple.
Args:
time_elements_tuple (Optional[tuple[str, str, str, str, str, str, str]]):
time elements, contains year, month, day of month, hours, minutes,
seconds and fraction of seconds.
Raises:
ValueError: if the time elements tuple is invalid.
"""
if len(time_elements_tuple) < 7:
raise ValueError((
'Invalid time elements tuple at least 7 elements required,'
'got: {0:d}').format(len(time_elements_tuple)))
super(TimeElementsWithFractionOfSecond, self).CopyFromStringTuple(
time_elements_tuple)
try:
fraction_of_second = decimal.Decimal(time_elements_tuple[6])
except (TypeError, ValueError):
raise ValueError('Invalid fraction of second value: {0!s}'.format(
time_elements_tuple[6]))
if fraction_of_second < 0.0 or fraction_of_second >= 1.0:
raise ValueError('Fraction of second value: {0:f} out of bounds.'.format(
fraction_of_second))
self.fraction_of_second = fraction_of_second |
Copies the time elements to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss" or
"YYYY-MM-DD hh:mm:ss.######" or None if time elements are missing.
Raises:
ValueError: if the precision value is unsupported.
def CopyToDateTimeString(self):
"""Copies the time elements to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss" or
"YYYY-MM-DD hh:mm:ss.######" or None if time elements are missing.
Raises:
ValueError: if the precision value is unsupported.
"""
if self._number_of_seconds is None or self.fraction_of_second is None:
return None
precision_helper = precisions.PrecisionHelperFactory.CreatePrecisionHelper(
self._precision)
return precision_helper.CopyToDateTimeString(
self._time_elements_tuple, self.fraction_of_second) |
Copies time elements from string-based time elements tuple.
Args:
time_elements_tuple (Optional[tuple[str, str, str, str, str, str, str]]):
time elements, contains year, month, day of month, hours, minutes,
seconds and milliseconds.
Raises:
ValueError: if the time elements tuple is invalid.
def CopyFromStringTuple(self, time_elements_tuple):
"""Copies time elements from string-based time elements tuple.
Args:
time_elements_tuple (Optional[tuple[str, str, str, str, str, str, str]]):
time elements, contains year, month, day of month, hours, minutes,
seconds and milliseconds.
Raises:
ValueError: if the time elements tuple is invalid.
"""
if len(time_elements_tuple) < 7:
raise ValueError((
'Invalid time elements tuple at least 7 elements required,'
'got: {0:d}').format(len(time_elements_tuple)))
year, month, day_of_month, hours, minutes, seconds, milliseconds = (
time_elements_tuple)
try:
milliseconds = int(milliseconds, 10)
except (TypeError, ValueError):
raise ValueError('Invalid millisecond value: {0!s}'.format(milliseconds))
if milliseconds < 0 or milliseconds >= definitions.MILLISECONDS_PER_SECOND:
raise ValueError('Invalid number of milliseconds.')
fraction_of_second = (
decimal.Decimal(milliseconds) / definitions.MILLISECONDS_PER_SECOND)
time_elements_tuple = (
year, month, day_of_month, hours, minutes, seconds,
str(fraction_of_second))
super(TimeElementsInMilliseconds, self).CopyFromStringTuple(
time_elements_tuple) |
Copies time elements from string-based time elements tuple.
Args:
time_elements_tuple (Optional[tuple[str, str, str, str, str, str, str]]):
time elements, contains year, month, day of month, hours, minutes,
seconds and microseconds.
Raises:
ValueError: if the time elements tuple is invalid.
def CopyFromStringTuple(self, time_elements_tuple):
"""Copies time elements from string-based time elements tuple.
Args:
time_elements_tuple (Optional[tuple[str, str, str, str, str, str, str]]):
time elements, contains year, month, day of month, hours, minutes,
seconds and microseconds.
Raises:
ValueError: if the time elements tuple is invalid.
"""
if len(time_elements_tuple) < 7:
raise ValueError((
'Invalid time elements tuple at least 7 elements required,'
'got: {0:d}').format(len(time_elements_tuple)))
year, month, day_of_month, hours, minutes, seconds, microseconds = (
time_elements_tuple)
try:
microseconds = int(microseconds, 10)
except (TypeError, ValueError):
raise ValueError('Invalid microsecond value: {0!s}'.format(microseconds))
if microseconds < 0 or microseconds >= definitions.MICROSECONDS_PER_SECOND:
raise ValueError('Invalid number of microseconds.')
fraction_of_second = (
decimal.Decimal(microseconds) / definitions.MICROSECONDS_PER_SECOND)
time_elements_tuple = (
year, month, day_of_month, hours, minutes, seconds,
str(fraction_of_second))
super(TimeElementsInMicroseconds, self).CopyFromStringTuple(
time_elements_tuple) |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._number_of_seconds is not None:
self._normalized_timestamp = (
decimal.Decimal(self.milliseconds) /
definitions.MILLISECONDS_PER_SECOND)
self._normalized_timestamp += decimal.Decimal(self._number_of_seconds)
return self._normalized_timestamp |
Copies a SYSTEMTIME structure from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
Raises:
ValueError: if the date string is invalid or not supported.
def CopyFromDateTimeString(self, time_string):
"""Copies a SYSTEMTIME structure from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
Raises:
ValueError: if the date string is invalid or not supported.
"""
date_time_values = self._CopyDateTimeFromString(time_string)
year = date_time_values.get('year', 0)
month = date_time_values.get('month', 0)
day_of_month = date_time_values.get('day_of_month', 0)
hours = date_time_values.get('hours', 0)
minutes = date_time_values.get('minutes', 0)
seconds = date_time_values.get('seconds', 0)
microseconds = date_time_values.get('microseconds', 0)
milliseconds, _ = divmod(
microseconds, definitions.MICROSECONDS_PER_MILLISECOND)
if year < 1601 or year > 30827:
raise ValueError('Unsupported year value: {0:d}.'.format(year))
self._normalized_timestamp = None
self._number_of_seconds = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
self.year = year
self.month = month
self.day_of_month = day_of_month
# TODO: calculate day of week on demand.
self.day_of_week = None
self.hours = hours
self.minutes = minutes
self.seconds = seconds
self.milliseconds = milliseconds
self.is_local_time = False |
Redirect messages to the dummy outbox
def send_messages(self, messages):
"""Redirect messages to the dummy outbox"""
msg_count = 0
for message in messages: # .message() triggers header validation
message.message()
msg_count += 1
mail.outbox.extend(messages)
return msg_count |
This is a copy of CharField.prepare_template, except that it adds a fake
request to the context, which is mainly needed to render CMS placeholders
def _prepare_template(self, obj, needs_request=False):
"""
This is a copy of CharField.prepare_template, except that it adds a fake
request to the context, which is mainly needed to render CMS placeholders
"""
if self.instance_name is None and self.template_name is None:
raise SearchFieldError("This field requires either its instance_name variable to be populated or an explicit template_name in order to load the correct template.")
if self.template_name is not None:
template_names = self.template_name
if not isinstance(template_names, (list, tuple)):
template_names = [template_names]
else:
template_names = ['search/indexes/%s/%s_%s.txt' % (obj._meta.app_label, obj._meta.module_name, self.instance_name)]
t = loader.select_template(template_names)
ctx = {'object': obj}
if needs_request:
request = rf.get("/")
request.session = {}
ctx['request'] = request
return t.render(Context(ctx)) |
gets the translated value of field name. If `FALLBACK`evaluates to `True` and the field
has no translation for the current language, it tries to find a fallback value, using
the languages defined in `settings.LANGUAGES`.
def get_value(self, context, obj, field_name):
"""
gets the translated value of field name. If `FALLBACK`evaluates to `True` and the field
has no translation for the current language, it tries to find a fallback value, using
the languages defined in `settings.LANGUAGES`.
"""
try:
language = get_language()
value = self.get_translated_value(obj, field_name, language)
if value:
return value
if self.FALLBACK:
for lang, lang_name in settings.LANGUAGES:
if lang == language:
# already tried this one...
continue
value = self.get_translated_value(obj, field_name, lang)
if value:
return value
untranslated = getattr(obj, field_name)
if self._is_truthy(untranslated):
return untranslated
else:
return self.EMPTY_VALUE
except Exception:
if settings.TEMPLATE_DEBUG:
raise
return self.EMPTY_VALUE |
A convenience function to ease debugging. It will print the node structure that's returned from CommonMark
The usage would be something like:
>>> content = Parser().parse('Some big text block\n===================\n\nwith content\n')
>>> customWalker(content)
document
heading
text Some big text block
paragraph
text with content
Spaces are used to convey nesting
def customWalker(node, space=''):
"""
A convenience function to ease debugging. It will print the node structure that's returned from CommonMark
The usage would be something like:
>>> content = Parser().parse('Some big text block\n===================\n\nwith content\n')
>>> customWalker(content)
document
heading
text Some big text block
paragraph
text with content
Spaces are used to convey nesting
"""
txt = ''
try:
txt = node.literal
except:
pass
if txt is None or txt == '':
print('{}{}'.format(space, node.t))
else:
print('{}{}\t{}'.format(space, node.t, txt))
cur = node.first_child
if cur:
while cur is not None:
customWalker(cur, space + ' ')
cur = cur.nxt |
Process a paragraph, which includes all content under it
def paragraph(node):
"""
Process a paragraph, which includes all content under it
"""
text = ''
if node.string_content is not None:
text = node.string_content
o = nodes.paragraph('', ' '.join(text))
o.line = node.sourcepos[0][0]
for n in MarkDown(node):
o.append(n)
return o |
A hyperlink. Note that alt text doesn't work, since there's no apparent way to do that in docutils
def reference(node):
"""
A hyperlink. Note that alt text doesn't work, since there's no apparent way to do that in docutils
"""
o = nodes.reference()
o['refuri'] = node.destination
if node.title:
o['name'] = node.title
for n in MarkDown(node):
o += n
return o |
An italicized section
def emphasis(node):
"""
An italicized section
"""
o = nodes.emphasis()
for n in MarkDown(node):
o += n
return o |
A bolded section
def strong(node):
"""
A bolded section
"""
o = nodes.strong()
for n in MarkDown(node):
o += n
return o |
Inline code
def literal(node):
"""
Inline code
"""
rendered = []
try:
if node.info is not None:
l = Lexer(node.literal, node.info, tokennames="long")
for _ in l:
rendered.append(node.inline(classes=_[0], text=_[1]))
except:
pass
classes = ['code']
if node.info is not None:
classes.append(node.info)
if len(rendered) > 0:
o = nodes.literal(classes=classes)
for element in rendered:
o += element
else:
o = nodes.literal(text=node.literal, classes=classes)
for n in MarkDown(node):
o += n
return o |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.