repository_name
stringlengths 7
55
| func_path_in_repository
stringlengths 4
223
| func_name
stringlengths 1
134
| whole_func_string
stringlengths 75
104k
| language
stringclasses 1
value | func_code_string
stringlengths 75
104k
| func_code_tokens
listlengths 19
28.4k
| func_documentation_string
stringlengths 1
46.9k
| func_documentation_tokens
listlengths 1
1.97k
| split_name
stringclasses 1
value | func_code_url
stringlengths 87
315
|
|---|---|---|---|---|---|---|---|---|---|---|
log2timeline/dfdatetime
|
dfdatetime/time_elements.py
|
TimeElements._CopyFromDateTimeValues
|
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
|
python
|
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
|
[
"def",
"_CopyFromDateTimeValues",
"(",
"self",
",",
"date_time_values",
")",
":",
"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 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.
|
[
"Copies",
"time",
"elements",
"from",
"date",
"and",
"time",
"values",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/time_elements.py#L119-L139
|
log2timeline/dfdatetime
|
dfdatetime/time_elements.py
|
TimeElements._CopyTimeFromStringISO8601
|
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
|
python
|
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
|
[
"def",
"_CopyTimeFromStringISO8601",
"(",
"self",
",",
"time_string",
")",
":",
"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 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.
|
[
"Copies",
"a",
"time",
"from",
"an",
"ISO",
"8601",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/time_elements.py#L141-L296
|
log2timeline/dfdatetime
|
dfdatetime/time_elements.py
|
TimeElements.CopyFromDateTimeString
|
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)
|
python
|
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)
|
[
"def",
"CopyFromDateTimeString",
"(",
"self",
",",
"time_string",
")",
":",
"date_time_values",
"=",
"self",
".",
"_CopyDateTimeFromString",
"(",
"time_string",
")",
"self",
".",
"_CopyFromDateTimeValues",
"(",
"date_time_values",
")"
] |
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.
|
[
"Copies",
"time",
"elements",
"from",
"a",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/time_elements.py#L298-L312
|
log2timeline/dfdatetime
|
dfdatetime/time_elements.py
|
TimeElements.CopyFromStringISO8601
|
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)
|
python
|
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)
|
[
"def",
"CopyFromStringISO8601",
"(",
"self",
",",
"time_string",
")",
":",
"date_time_values",
"=",
"self",
".",
"_CopyDateTimeFromStringISO8601",
"(",
"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.
|
[
"Copies",
"time",
"elements",
"from",
"an",
"ISO",
"8601",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/time_elements.py#L314-L338
|
log2timeline/dfdatetime
|
dfdatetime/time_elements.py
|
TimeElements.CopyFromStringTuple
|
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)
|
python
|
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)
|
[
"def",
"CopyFromStringTuple",
"(",
"self",
",",
"time_elements_tuple",
")",
":",
"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 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.
|
[
"Copies",
"time",
"elements",
"from",
"string",
"-",
"based",
"time",
"elements",
"tuple",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/time_elements.py#L340-L396
|
log2timeline/dfdatetime
|
dfdatetime/time_elements.py
|
TimeElements.CopyToDateTimeString
|
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])
|
python
|
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])
|
[
"def",
"CopyToDateTimeString",
"(",
"self",
")",
":",
"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 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.
|
[
"Copies",
"the",
"time",
"elements",
"to",
"a",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/time_elements.py#L398-L411
|
log2timeline/dfdatetime
|
dfdatetime/time_elements.py
|
TimeElementsWithFractionOfSecond._CopyFromDateTimeValues
|
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
|
python
|
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
|
[
"def",
"_CopyFromDateTimeValues",
"(",
"self",
",",
"date_time_values",
")",
":",
"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 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.
|
[
"Copies",
"time",
"elements",
"from",
"date",
"and",
"time",
"values",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/time_elements.py#L465-L495
|
log2timeline/dfdatetime
|
dfdatetime/time_elements.py
|
TimeElementsWithFractionOfSecond.CopyFromStringTuple
|
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
|
python
|
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
|
[
"def",
"CopyFromStringTuple",
"(",
"self",
",",
"time_elements_tuple",
")",
":",
"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 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.
|
[
"Copies",
"time",
"elements",
"from",
"string",
"-",
"based",
"time",
"elements",
"tuple",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/time_elements.py#L497-L526
|
log2timeline/dfdatetime
|
dfdatetime/time_elements.py
|
TimeElementsWithFractionOfSecond.CopyToDateTimeString
|
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)
|
python
|
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)
|
[
"def",
"CopyToDateTimeString",
"(",
"self",
")",
":",
"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 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.
|
[
"Copies",
"the",
"time",
"elements",
"to",
"a",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/time_elements.py#L528-L545
|
log2timeline/dfdatetime
|
dfdatetime/time_elements.py
|
TimeElementsInMilliseconds.CopyFromStringTuple
|
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)
|
python
|
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)
|
[
"def",
"CopyFromStringTuple",
"(",
"self",
",",
"time_elements_tuple",
")",
":",
"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 milliseconds.
Raises:
ValueError: if the time elements tuple is invalid.
|
[
"Copies",
"time",
"elements",
"from",
"string",
"-",
"based",
"time",
"elements",
"tuple",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/time_elements.py#L597-L632
|
log2timeline/dfdatetime
|
dfdatetime/time_elements.py
|
TimeElementsInMicroseconds.CopyFromStringTuple
|
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)
|
python
|
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)
|
[
"def",
"CopyFromStringTuple",
"(",
"self",
",",
"time_elements_tuple",
")",
":",
"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",
")"
] |
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.
|
[
"Copies",
"time",
"elements",
"from",
"string",
"-",
"based",
"time",
"elements",
"tuple",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/time_elements.py#L684-L719
|
log2timeline/dfdatetime
|
dfdatetime/systemtime.py
|
Systemtime._GetNormalizedTimestamp
|
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
|
python
|
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
|
[
"def",
"_GetNormalizedTimestamp",
"(",
"self",
")",
":",
"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"
] |
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.
|
[
"Retrieves",
"the",
"normalized",
"timestamp",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/systemtime.py#L109-L125
|
log2timeline/dfdatetime
|
dfdatetime/systemtime.py
|
Systemtime.CopyFromDateTimeString
|
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
|
python
|
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
|
[
"def",
"CopyFromDateTimeString",
"(",
"self",
",",
"time_string",
")",
":",
"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"
] |
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.
|
[
"Copies",
"a",
"SYSTEMTIME",
"structure",
"from",
"a",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/systemtime.py#L127-L172
|
RyanBalfanz/django-smsish
|
smsish/sms/backends/locmem.py
|
SMSBackend.send_messages
|
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
|
python
|
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
|
[
"def",
"send_messages",
"(",
"self",
",",
"messages",
")",
":",
"msg_count",
"=",
"0",
"for",
"message",
"in",
"messages",
":",
"# .message() triggers header validation",
"message",
".",
"message",
"(",
")",
"msg_count",
"+=",
"1",
"mail",
".",
"outbox",
".",
"extend",
"(",
"messages",
")",
"return",
"msg_count"
] |
Redirect messages to the dummy outbox
|
[
"Redirect",
"messages",
"to",
"the",
"dummy",
"outbox"
] |
train
|
https://github.com/RyanBalfanz/django-smsish/blob/4d450e3d217cea9e373f16c5e4f0beb3218bd5c9/smsish/sms/backends/locmem.py#L20-L27
|
beniwohli/django-cms-search
|
cms_search/search_helpers/fields.py
|
MultiLangTemplateField._prepare_template
|
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))
|
python
|
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))
|
[
"def",
"_prepare_template",
"(",
"self",
",",
"obj",
",",
"needs_request",
"=",
"False",
")",
":",
"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",
")",
")"
] |
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
|
[
"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"
] |
train
|
https://github.com/beniwohli/django-cms-search/blob/57a1508fabd2285252b8f7e8ff778f2b7c2f3656/cms_search/search_helpers/fields.py#L31-L53
|
beniwohli/django-cms-search
|
cms_search/search_helpers/templatetags/cms_search_tags.py
|
GetTransFieldTag.get_value
|
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
|
python
|
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
|
[
"def",
"get_value",
"(",
"self",
",",
"context",
",",
"obj",
",",
"field_name",
")",
":",
"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"
] |
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`.
|
[
"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",
"."
] |
train
|
https://github.com/beniwohli/django-cms-search/blob/57a1508fabd2285252b8f7e8ff778f2b7c2f3656/cms_search/search_helpers/templatetags/cms_search_tags.py#L29-L57
|
ribozz/sphinx-argparse
|
sphinxarg/markdown.py
|
customWalker
|
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
|
python
|
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
|
[
"def",
"customWalker",
"(",
"node",
",",
"space",
"=",
"''",
")",
":",
"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"
] |
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
|
[
"A",
"convenience",
"function",
"to",
"ease",
"debugging",
".",
"It",
"will",
"print",
"the",
"node",
"structure",
"that",
"s",
"returned",
"from",
"CommonMark"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/markdown.py#L13-L44
|
ribozz/sphinx-argparse
|
sphinxarg/markdown.py
|
paragraph
|
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
|
python
|
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
|
[
"def",
"paragraph",
"(",
"node",
")",
":",
"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"
] |
Process a paragraph, which includes all content under it
|
[
"Process",
"a",
"paragraph",
"which",
"includes",
"all",
"content",
"under",
"it"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/markdown.py#L47-L59
|
ribozz/sphinx-argparse
|
sphinxarg/markdown.py
|
reference
|
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
|
python
|
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
|
[
"def",
"reference",
"(",
"node",
")",
":",
"o",
"=",
"nodes",
".",
"reference",
"(",
")",
"o",
"[",
"'refuri'",
"]",
"=",
"node",
".",
"destination",
"if",
"node",
".",
"title",
":",
"o",
"[",
"'name'",
"]",
"=",
"node",
".",
"title",
"for",
"n",
"in",
"MarkDown",
"(",
"node",
")",
":",
"o",
"+=",
"n",
"return",
"o"
] |
A hyperlink. Note that alt text doesn't work, since there's no apparent way to do that in docutils
|
[
"A",
"hyperlink",
".",
"Note",
"that",
"alt",
"text",
"doesn",
"t",
"work",
"since",
"there",
"s",
"no",
"apparent",
"way",
"to",
"do",
"that",
"in",
"docutils"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/markdown.py#L83-L93
|
ribozz/sphinx-argparse
|
sphinxarg/markdown.py
|
emphasis
|
def emphasis(node):
"""
An italicized section
"""
o = nodes.emphasis()
for n in MarkDown(node):
o += n
return o
|
python
|
def emphasis(node):
"""
An italicized section
"""
o = nodes.emphasis()
for n in MarkDown(node):
o += n
return o
|
[
"def",
"emphasis",
"(",
"node",
")",
":",
"o",
"=",
"nodes",
".",
"emphasis",
"(",
")",
"for",
"n",
"in",
"MarkDown",
"(",
"node",
")",
":",
"o",
"+=",
"n",
"return",
"o"
] |
An italicized section
|
[
"An",
"italicized",
"section"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/markdown.py#L96-L103
|
ribozz/sphinx-argparse
|
sphinxarg/markdown.py
|
strong
|
def strong(node):
"""
A bolded section
"""
o = nodes.strong()
for n in MarkDown(node):
o += n
return o
|
python
|
def strong(node):
"""
A bolded section
"""
o = nodes.strong()
for n in MarkDown(node):
o += n
return o
|
[
"def",
"strong",
"(",
"node",
")",
":",
"o",
"=",
"nodes",
".",
"strong",
"(",
")",
"for",
"n",
"in",
"MarkDown",
"(",
"node",
")",
":",
"o",
"+=",
"n",
"return",
"o"
] |
A bolded section
|
[
"A",
"bolded",
"section"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/markdown.py#L106-L113
|
ribozz/sphinx-argparse
|
sphinxarg/markdown.py
|
literal
|
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
|
python
|
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
|
[
"def",
"literal",
"(",
"node",
")",
":",
"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"
] |
Inline code
|
[
"Inline",
"code"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/markdown.py#L116-L141
|
ribozz/sphinx-argparse
|
sphinxarg/markdown.py
|
raw
|
def raw(node):
"""
Add some raw html (possibly as a block)
"""
o = nodes.raw(node.literal, node.literal, format='html')
if node.sourcepos is not None:
o.line = node.sourcepos[0][0]
for n in MarkDown(node):
o += n
return o
|
python
|
def raw(node):
"""
Add some raw html (possibly as a block)
"""
o = nodes.raw(node.literal, node.literal, format='html')
if node.sourcepos is not None:
o.line = node.sourcepos[0][0]
for n in MarkDown(node):
o += n
return o
|
[
"def",
"raw",
"(",
"node",
")",
":",
"o",
"=",
"nodes",
".",
"raw",
"(",
"node",
".",
"literal",
",",
"node",
".",
"literal",
",",
"format",
"=",
"'html'",
")",
"if",
"node",
".",
"sourcepos",
"is",
"not",
"None",
":",
"o",
".",
"line",
"=",
"node",
".",
"sourcepos",
"[",
"0",
"]",
"[",
"0",
"]",
"for",
"n",
"in",
"MarkDown",
"(",
"node",
")",
":",
"o",
"+=",
"n",
"return",
"o"
] |
Add some raw html (possibly as a block)
|
[
"Add",
"some",
"raw",
"html",
"(",
"possibly",
"as",
"a",
"block",
")"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/markdown.py#L173-L182
|
ribozz/sphinx-argparse
|
sphinxarg/markdown.py
|
title
|
def title(node):
"""
A title node. It has no children
"""
return nodes.title(node.first_child.literal, node.first_child.literal)
|
python
|
def title(node):
"""
A title node. It has no children
"""
return nodes.title(node.first_child.literal, node.first_child.literal)
|
[
"def",
"title",
"(",
"node",
")",
":",
"return",
"nodes",
".",
"title",
"(",
"node",
".",
"first_child",
".",
"literal",
",",
"node",
".",
"first_child",
".",
"literal",
")"
] |
A title node. It has no children
|
[
"A",
"title",
"node",
".",
"It",
"has",
"no",
"children"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/markdown.py#L192-L196
|
ribozz/sphinx-argparse
|
sphinxarg/markdown.py
|
section
|
def section(node):
"""
A section in reStructuredText, which needs a title (the first child)
This is a custom type
"""
title = '' # All sections need an id
if node.first_child is not None:
if node.first_child.t == u'heading':
title = node.first_child.first_child.literal
o = nodes.section(ids=[title], names=[title])
for n in MarkDown(node):
o += n
return o
|
python
|
def section(node):
"""
A section in reStructuredText, which needs a title (the first child)
This is a custom type
"""
title = '' # All sections need an id
if node.first_child is not None:
if node.first_child.t == u'heading':
title = node.first_child.first_child.literal
o = nodes.section(ids=[title], names=[title])
for n in MarkDown(node):
o += n
return o
|
[
"def",
"section",
"(",
"node",
")",
":",
"title",
"=",
"''",
"# All sections need an id",
"if",
"node",
".",
"first_child",
"is",
"not",
"None",
":",
"if",
"node",
".",
"first_child",
".",
"t",
"==",
"u'heading'",
":",
"title",
"=",
"node",
".",
"first_child",
".",
"first_child",
".",
"literal",
"o",
"=",
"nodes",
".",
"section",
"(",
"ids",
"=",
"[",
"title",
"]",
",",
"names",
"=",
"[",
"title",
"]",
")",
"for",
"n",
"in",
"MarkDown",
"(",
"node",
")",
":",
"o",
"+=",
"n",
"return",
"o"
] |
A section in reStructuredText, which needs a title (the first child)
This is a custom type
|
[
"A",
"section",
"in",
"reStructuredText",
"which",
"needs",
"a",
"title",
"(",
"the",
"first",
"child",
")",
"This",
"is",
"a",
"custom",
"type"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/markdown.py#L199-L211
|
ribozz/sphinx-argparse
|
sphinxarg/markdown.py
|
block_quote
|
def block_quote(node):
"""
A block quote
"""
o = nodes.block_quote()
o.line = node.sourcepos[0][0]
for n in MarkDown(node):
o += n
return o
|
python
|
def block_quote(node):
"""
A block quote
"""
o = nodes.block_quote()
o.line = node.sourcepos[0][0]
for n in MarkDown(node):
o += n
return o
|
[
"def",
"block_quote",
"(",
"node",
")",
":",
"o",
"=",
"nodes",
".",
"block_quote",
"(",
")",
"o",
".",
"line",
"=",
"node",
".",
"sourcepos",
"[",
"0",
"]",
"[",
"0",
"]",
"for",
"n",
"in",
"MarkDown",
"(",
"node",
")",
":",
"o",
"+=",
"n",
"return",
"o"
] |
A block quote
|
[
"A",
"block",
"quote"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/markdown.py#L214-L222
|
ribozz/sphinx-argparse
|
sphinxarg/markdown.py
|
image
|
def image(node):
"""
An image element
The first child is the alt text. reStructuredText can't handle titles
"""
o = nodes.image(uri=node.destination)
if node.first_child is not None:
o['alt'] = node.first_child.literal
return o
|
python
|
def image(node):
"""
An image element
The first child is the alt text. reStructuredText can't handle titles
"""
o = nodes.image(uri=node.destination)
if node.first_child is not None:
o['alt'] = node.first_child.literal
return o
|
[
"def",
"image",
"(",
"node",
")",
":",
"o",
"=",
"nodes",
".",
"image",
"(",
"uri",
"=",
"node",
".",
"destination",
")",
"if",
"node",
".",
"first_child",
"is",
"not",
"None",
":",
"o",
"[",
"'alt'",
"]",
"=",
"node",
".",
"first_child",
".",
"literal",
"return",
"o"
] |
An image element
The first child is the alt text. reStructuredText can't handle titles
|
[
"An",
"image",
"element"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/markdown.py#L225-L234
|
ribozz/sphinx-argparse
|
sphinxarg/markdown.py
|
listItem
|
def listItem(node):
"""
An item in a list
"""
o = nodes.list_item()
for n in MarkDown(node):
o += n
return o
|
python
|
def listItem(node):
"""
An item in a list
"""
o = nodes.list_item()
for n in MarkDown(node):
o += n
return o
|
[
"def",
"listItem",
"(",
"node",
")",
":",
"o",
"=",
"nodes",
".",
"list_item",
"(",
")",
"for",
"n",
"in",
"MarkDown",
"(",
"node",
")",
":",
"o",
"+=",
"n",
"return",
"o"
] |
An item in a list
|
[
"An",
"item",
"in",
"a",
"list"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/markdown.py#L237-L244
|
ribozz/sphinx-argparse
|
sphinxarg/markdown.py
|
listNode
|
def listNode(node):
"""
A list (numbered or not)
For numbered lists, the suffix is only rendered as . in html
"""
if node.list_data['type'] == u'bullet':
o = nodes.bullet_list(bullet=node.list_data['bullet_char'])
else:
o = nodes.enumerated_list(suffix=node.list_data['delimiter'], enumtype='arabic', start=node.list_data['start'])
for n in MarkDown(node):
o += n
return o
|
python
|
def listNode(node):
"""
A list (numbered or not)
For numbered lists, the suffix is only rendered as . in html
"""
if node.list_data['type'] == u'bullet':
o = nodes.bullet_list(bullet=node.list_data['bullet_char'])
else:
o = nodes.enumerated_list(suffix=node.list_data['delimiter'], enumtype='arabic', start=node.list_data['start'])
for n in MarkDown(node):
o += n
return o
|
[
"def",
"listNode",
"(",
"node",
")",
":",
"if",
"node",
".",
"list_data",
"[",
"'type'",
"]",
"==",
"u'bullet'",
":",
"o",
"=",
"nodes",
".",
"bullet_list",
"(",
"bullet",
"=",
"node",
".",
"list_data",
"[",
"'bullet_char'",
"]",
")",
"else",
":",
"o",
"=",
"nodes",
".",
"enumerated_list",
"(",
"suffix",
"=",
"node",
".",
"list_data",
"[",
"'delimiter'",
"]",
",",
"enumtype",
"=",
"'arabic'",
",",
"start",
"=",
"node",
".",
"list_data",
"[",
"'start'",
"]",
")",
"for",
"n",
"in",
"MarkDown",
"(",
"node",
")",
":",
"o",
"+=",
"n",
"return",
"o"
] |
A list (numbered or not)
For numbered lists, the suffix is only rendered as . in html
|
[
"A",
"list",
"(",
"numbered",
"or",
"not",
")",
"For",
"numbered",
"lists",
"the",
"suffix",
"is",
"only",
"rendered",
"as",
".",
"in",
"html"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/markdown.py#L247-L258
|
ribozz/sphinx-argparse
|
sphinxarg/markdown.py
|
MarkDown
|
def MarkDown(node):
"""
Returns a list of nodes, containing CommonMark nodes converted to docutils nodes
"""
cur = node.first_child
# Go into each child, in turn
output = []
while cur is not None:
t = cur.t
if t == 'paragraph':
output.append(paragraph(cur))
elif t == 'text':
output.append(text(cur))
elif t == 'softbreak':
output.append(softbreak(cur))
elif t == 'linebreak':
output.append(hardbreak(cur))
elif t == 'link':
output.append(reference(cur))
elif t == 'heading':
output.append(title(cur))
elif t == 'emph':
output.append(emphasis(cur))
elif t == 'strong':
output.append(strong(cur))
elif t == 'code':
output.append(literal(cur))
elif t == 'code_block':
output.append(literal_block(cur))
elif t == 'html_inline' or t == 'html_block':
output.append(raw(cur))
elif t == 'block_quote':
output.append(block_quote(cur))
elif t == 'thematic_break':
output.append(transition(cur))
elif t == 'image':
output.append(image(cur))
elif t == 'list':
output.append(listNode(cur))
elif t == 'item':
output.append(listItem(cur))
elif t == 'MDsection':
output.append(section(cur))
else:
print('Received unhandled type: {}. Full print of node:'.format(t))
cur.pretty()
cur = cur.nxt
return output
|
python
|
def MarkDown(node):
"""
Returns a list of nodes, containing CommonMark nodes converted to docutils nodes
"""
cur = node.first_child
# Go into each child, in turn
output = []
while cur is not None:
t = cur.t
if t == 'paragraph':
output.append(paragraph(cur))
elif t == 'text':
output.append(text(cur))
elif t == 'softbreak':
output.append(softbreak(cur))
elif t == 'linebreak':
output.append(hardbreak(cur))
elif t == 'link':
output.append(reference(cur))
elif t == 'heading':
output.append(title(cur))
elif t == 'emph':
output.append(emphasis(cur))
elif t == 'strong':
output.append(strong(cur))
elif t == 'code':
output.append(literal(cur))
elif t == 'code_block':
output.append(literal_block(cur))
elif t == 'html_inline' or t == 'html_block':
output.append(raw(cur))
elif t == 'block_quote':
output.append(block_quote(cur))
elif t == 'thematic_break':
output.append(transition(cur))
elif t == 'image':
output.append(image(cur))
elif t == 'list':
output.append(listNode(cur))
elif t == 'item':
output.append(listItem(cur))
elif t == 'MDsection':
output.append(section(cur))
else:
print('Received unhandled type: {}. Full print of node:'.format(t))
cur.pretty()
cur = cur.nxt
return output
|
[
"def",
"MarkDown",
"(",
"node",
")",
":",
"cur",
"=",
"node",
".",
"first_child",
"# Go into each child, in turn",
"output",
"=",
"[",
"]",
"while",
"cur",
"is",
"not",
"None",
":",
"t",
"=",
"cur",
".",
"t",
"if",
"t",
"==",
"'paragraph'",
":",
"output",
".",
"append",
"(",
"paragraph",
"(",
"cur",
")",
")",
"elif",
"t",
"==",
"'text'",
":",
"output",
".",
"append",
"(",
"text",
"(",
"cur",
")",
")",
"elif",
"t",
"==",
"'softbreak'",
":",
"output",
".",
"append",
"(",
"softbreak",
"(",
"cur",
")",
")",
"elif",
"t",
"==",
"'linebreak'",
":",
"output",
".",
"append",
"(",
"hardbreak",
"(",
"cur",
")",
")",
"elif",
"t",
"==",
"'link'",
":",
"output",
".",
"append",
"(",
"reference",
"(",
"cur",
")",
")",
"elif",
"t",
"==",
"'heading'",
":",
"output",
".",
"append",
"(",
"title",
"(",
"cur",
")",
")",
"elif",
"t",
"==",
"'emph'",
":",
"output",
".",
"append",
"(",
"emphasis",
"(",
"cur",
")",
")",
"elif",
"t",
"==",
"'strong'",
":",
"output",
".",
"append",
"(",
"strong",
"(",
"cur",
")",
")",
"elif",
"t",
"==",
"'code'",
":",
"output",
".",
"append",
"(",
"literal",
"(",
"cur",
")",
")",
"elif",
"t",
"==",
"'code_block'",
":",
"output",
".",
"append",
"(",
"literal_block",
"(",
"cur",
")",
")",
"elif",
"t",
"==",
"'html_inline'",
"or",
"t",
"==",
"'html_block'",
":",
"output",
".",
"append",
"(",
"raw",
"(",
"cur",
")",
")",
"elif",
"t",
"==",
"'block_quote'",
":",
"output",
".",
"append",
"(",
"block_quote",
"(",
"cur",
")",
")",
"elif",
"t",
"==",
"'thematic_break'",
":",
"output",
".",
"append",
"(",
"transition",
"(",
"cur",
")",
")",
"elif",
"t",
"==",
"'image'",
":",
"output",
".",
"append",
"(",
"image",
"(",
"cur",
")",
")",
"elif",
"t",
"==",
"'list'",
":",
"output",
".",
"append",
"(",
"listNode",
"(",
"cur",
")",
")",
"elif",
"t",
"==",
"'item'",
":",
"output",
".",
"append",
"(",
"listItem",
"(",
"cur",
")",
")",
"elif",
"t",
"==",
"'MDsection'",
":",
"output",
".",
"append",
"(",
"section",
"(",
"cur",
")",
")",
"else",
":",
"print",
"(",
"'Received unhandled type: {}. Full print of node:'",
".",
"format",
"(",
"t",
")",
")",
"cur",
".",
"pretty",
"(",
")",
"cur",
"=",
"cur",
".",
"nxt",
"return",
"output"
] |
Returns a list of nodes, containing CommonMark nodes converted to docutils nodes
|
[
"Returns",
"a",
"list",
"of",
"nodes",
"containing",
"CommonMark",
"nodes",
"converted",
"to",
"docutils",
"nodes"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/markdown.py#L261-L311
|
ribozz/sphinx-argparse
|
sphinxarg/markdown.py
|
finalizeSection
|
def finalizeSection(section):
"""
Correct the nxt and parent for each child
"""
cur = section.first_child
last = section.last_child
if last is not None:
last.nxt = None
while cur is not None:
cur.parent = section
cur = cur.nxt
|
python
|
def finalizeSection(section):
"""
Correct the nxt and parent for each child
"""
cur = section.first_child
last = section.last_child
if last is not None:
last.nxt = None
while cur is not None:
cur.parent = section
cur = cur.nxt
|
[
"def",
"finalizeSection",
"(",
"section",
")",
":",
"cur",
"=",
"section",
".",
"first_child",
"last",
"=",
"section",
".",
"last_child",
"if",
"last",
"is",
"not",
"None",
":",
"last",
".",
"nxt",
"=",
"None",
"while",
"cur",
"is",
"not",
"None",
":",
"cur",
".",
"parent",
"=",
"section",
"cur",
"=",
"cur",
".",
"nxt"
] |
Correct the nxt and parent for each child
|
[
"Correct",
"the",
"nxt",
"and",
"parent",
"for",
"each",
"child"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/markdown.py#L314-L325
|
ribozz/sphinx-argparse
|
sphinxarg/markdown.py
|
nestSections
|
def nestSections(block, level=1):
"""
Sections aren't handled by CommonMark at the moment.
This function adds sections to a block of nodes.
'title' nodes with an assigned level below 'level' will be put in a child section.
If there are no child nodes with titles of level 'level' then nothing is done
"""
cur = block.first_child
if cur is not None:
children = []
# Do we need to do anything?
nest = False
while cur is not None:
if cur.t == 'heading' and cur.level == level:
nest = True
break
cur = cur.nxt
if not nest:
return
section = Node('MDsection', 0)
section.parent = block
cur = block.first_child
while cur is not None:
if cur.t == 'heading' and cur.level == level:
# Found a split point, flush the last section if needed
if section.first_child is not None:
finalizeSection(section)
children.append(section)
section = Node('MDsection', 0)
nxt = cur.nxt
# Avoid adding sections without titles at the start
if section.first_child is None:
if cur.t == 'heading' and cur.level == level:
section.append_child(cur)
else:
children.append(cur)
else:
section.append_child(cur)
cur = nxt
# If there's only 1 child then don't bother
if section.first_child is not None:
finalizeSection(section)
children.append(section)
block.first_child = None
block.last_child = None
nextLevel = level + 1
for child in children:
# Handle nesting
if child.t == 'MDsection':
nestSections(child, level=nextLevel)
# Append
if block.first_child is None:
block.first_child = child
else:
block.last_child.nxt = child
child.parent = block
child.nxt = None
child.prev = block.last_child
block.last_child = child
|
python
|
def nestSections(block, level=1):
"""
Sections aren't handled by CommonMark at the moment.
This function adds sections to a block of nodes.
'title' nodes with an assigned level below 'level' will be put in a child section.
If there are no child nodes with titles of level 'level' then nothing is done
"""
cur = block.first_child
if cur is not None:
children = []
# Do we need to do anything?
nest = False
while cur is not None:
if cur.t == 'heading' and cur.level == level:
nest = True
break
cur = cur.nxt
if not nest:
return
section = Node('MDsection', 0)
section.parent = block
cur = block.first_child
while cur is not None:
if cur.t == 'heading' and cur.level == level:
# Found a split point, flush the last section if needed
if section.first_child is not None:
finalizeSection(section)
children.append(section)
section = Node('MDsection', 0)
nxt = cur.nxt
# Avoid adding sections without titles at the start
if section.first_child is None:
if cur.t == 'heading' and cur.level == level:
section.append_child(cur)
else:
children.append(cur)
else:
section.append_child(cur)
cur = nxt
# If there's only 1 child then don't bother
if section.first_child is not None:
finalizeSection(section)
children.append(section)
block.first_child = None
block.last_child = None
nextLevel = level + 1
for child in children:
# Handle nesting
if child.t == 'MDsection':
nestSections(child, level=nextLevel)
# Append
if block.first_child is None:
block.first_child = child
else:
block.last_child.nxt = child
child.parent = block
child.nxt = None
child.prev = block.last_child
block.last_child = child
|
[
"def",
"nestSections",
"(",
"block",
",",
"level",
"=",
"1",
")",
":",
"cur",
"=",
"block",
".",
"first_child",
"if",
"cur",
"is",
"not",
"None",
":",
"children",
"=",
"[",
"]",
"# Do we need to do anything?",
"nest",
"=",
"False",
"while",
"cur",
"is",
"not",
"None",
":",
"if",
"cur",
".",
"t",
"==",
"'heading'",
"and",
"cur",
".",
"level",
"==",
"level",
":",
"nest",
"=",
"True",
"break",
"cur",
"=",
"cur",
".",
"nxt",
"if",
"not",
"nest",
":",
"return",
"section",
"=",
"Node",
"(",
"'MDsection'",
",",
"0",
")",
"section",
".",
"parent",
"=",
"block",
"cur",
"=",
"block",
".",
"first_child",
"while",
"cur",
"is",
"not",
"None",
":",
"if",
"cur",
".",
"t",
"==",
"'heading'",
"and",
"cur",
".",
"level",
"==",
"level",
":",
"# Found a split point, flush the last section if needed",
"if",
"section",
".",
"first_child",
"is",
"not",
"None",
":",
"finalizeSection",
"(",
"section",
")",
"children",
".",
"append",
"(",
"section",
")",
"section",
"=",
"Node",
"(",
"'MDsection'",
",",
"0",
")",
"nxt",
"=",
"cur",
".",
"nxt",
"# Avoid adding sections without titles at the start",
"if",
"section",
".",
"first_child",
"is",
"None",
":",
"if",
"cur",
".",
"t",
"==",
"'heading'",
"and",
"cur",
".",
"level",
"==",
"level",
":",
"section",
".",
"append_child",
"(",
"cur",
")",
"else",
":",
"children",
".",
"append",
"(",
"cur",
")",
"else",
":",
"section",
".",
"append_child",
"(",
"cur",
")",
"cur",
"=",
"nxt",
"# If there's only 1 child then don't bother",
"if",
"section",
".",
"first_child",
"is",
"not",
"None",
":",
"finalizeSection",
"(",
"section",
")",
"children",
".",
"append",
"(",
"section",
")",
"block",
".",
"first_child",
"=",
"None",
"block",
".",
"last_child",
"=",
"None",
"nextLevel",
"=",
"level",
"+",
"1",
"for",
"child",
"in",
"children",
":",
"# Handle nesting",
"if",
"child",
".",
"t",
"==",
"'MDsection'",
":",
"nestSections",
"(",
"child",
",",
"level",
"=",
"nextLevel",
")",
"# Append",
"if",
"block",
".",
"first_child",
"is",
"None",
":",
"block",
".",
"first_child",
"=",
"child",
"else",
":",
"block",
".",
"last_child",
".",
"nxt",
"=",
"child",
"child",
".",
"parent",
"=",
"block",
"child",
".",
"nxt",
"=",
"None",
"child",
".",
"prev",
"=",
"block",
".",
"last_child",
"block",
".",
"last_child",
"=",
"child"
] |
Sections aren't handled by CommonMark at the moment.
This function adds sections to a block of nodes.
'title' nodes with an assigned level below 'level' will be put in a child section.
If there are no child nodes with titles of level 'level' then nothing is done
|
[
"Sections",
"aren",
"t",
"handled",
"by",
"CommonMark",
"at",
"the",
"moment",
".",
"This",
"function",
"adds",
"sections",
"to",
"a",
"block",
"of",
"nodes",
".",
"title",
"nodes",
"with",
"an",
"assigned",
"level",
"below",
"level",
"will",
"be",
"put",
"in",
"a",
"child",
"section",
".",
"If",
"there",
"are",
"no",
"child",
"nodes",
"with",
"titles",
"of",
"level",
"level",
"then",
"nothing",
"is",
"done"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/markdown.py#L328-L390
|
ribozz/sphinx-argparse
|
sphinxarg/markdown.py
|
parseMarkDownBlock
|
def parseMarkDownBlock(text):
"""
Parses a block of text, returning a list of docutils nodes
>>> parseMarkdownBlock("Some\n====\n\nblock of text\n\nHeader\n======\n\nblah\n")
[]
"""
block = Parser().parse(text)
# CommonMark can't nest sections, so do it manually
nestSections(block)
return MarkDown(block)
|
python
|
def parseMarkDownBlock(text):
"""
Parses a block of text, returning a list of docutils nodes
>>> parseMarkdownBlock("Some\n====\n\nblock of text\n\nHeader\n======\n\nblah\n")
[]
"""
block = Parser().parse(text)
# CommonMark can't nest sections, so do it manually
nestSections(block)
return MarkDown(block)
|
[
"def",
"parseMarkDownBlock",
"(",
"text",
")",
":",
"block",
"=",
"Parser",
"(",
")",
".",
"parse",
"(",
"text",
")",
"# CommonMark can't nest sections, so do it manually",
"nestSections",
"(",
"block",
")",
"return",
"MarkDown",
"(",
"block",
")"
] |
Parses a block of text, returning a list of docutils nodes
>>> parseMarkdownBlock("Some\n====\n\nblock of text\n\nHeader\n======\n\nblah\n")
[]
|
[
"Parses",
"a",
"block",
"of",
"text",
"returning",
"a",
"list",
"of",
"docutils",
"nodes"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/markdown.py#L393-L404
|
ribozz/sphinx-argparse
|
sphinxarg/ext.py
|
renderList
|
def renderList(l, markDownHelp, settings=None):
"""
Given a list of reStructuredText or MarkDown sections, return a docutils node list
"""
if len(l) == 0:
return []
if markDownHelp:
from sphinxarg.markdown import parseMarkDownBlock
return parseMarkDownBlock('\n\n'.join(l) + '\n')
else:
all_children = []
for element in l:
if isinstance(element, str):
if settings is None:
settings = OptionParser(components=(Parser,)).get_default_values()
document = new_document(None, settings)
Parser().parse(element + '\n', document)
all_children += document.children
elif isinstance(element, nodes.definition):
all_children += element
return all_children
|
python
|
def renderList(l, markDownHelp, settings=None):
"""
Given a list of reStructuredText or MarkDown sections, return a docutils node list
"""
if len(l) == 0:
return []
if markDownHelp:
from sphinxarg.markdown import parseMarkDownBlock
return parseMarkDownBlock('\n\n'.join(l) + '\n')
else:
all_children = []
for element in l:
if isinstance(element, str):
if settings is None:
settings = OptionParser(components=(Parser,)).get_default_values()
document = new_document(None, settings)
Parser().parse(element + '\n', document)
all_children += document.children
elif isinstance(element, nodes.definition):
all_children += element
return all_children
|
[
"def",
"renderList",
"(",
"l",
",",
"markDownHelp",
",",
"settings",
"=",
"None",
")",
":",
"if",
"len",
"(",
"l",
")",
"==",
"0",
":",
"return",
"[",
"]",
"if",
"markDownHelp",
":",
"from",
"sphinxarg",
".",
"markdown",
"import",
"parseMarkDownBlock",
"return",
"parseMarkDownBlock",
"(",
"'\\n\\n'",
".",
"join",
"(",
"l",
")",
"+",
"'\\n'",
")",
"else",
":",
"all_children",
"=",
"[",
"]",
"for",
"element",
"in",
"l",
":",
"if",
"isinstance",
"(",
"element",
",",
"str",
")",
":",
"if",
"settings",
"is",
"None",
":",
"settings",
"=",
"OptionParser",
"(",
"components",
"=",
"(",
"Parser",
",",
")",
")",
".",
"get_default_values",
"(",
")",
"document",
"=",
"new_document",
"(",
"None",
",",
"settings",
")",
"Parser",
"(",
")",
".",
"parse",
"(",
"element",
"+",
"'\\n'",
",",
"document",
")",
"all_children",
"+=",
"document",
".",
"children",
"elif",
"isinstance",
"(",
"element",
",",
"nodes",
".",
"definition",
")",
":",
"all_children",
"+=",
"element",
"return",
"all_children"
] |
Given a list of reStructuredText or MarkDown sections, return a docutils node list
|
[
"Given",
"a",
"list",
"of",
"reStructuredText",
"or",
"MarkDown",
"sections",
"return",
"a",
"docutils",
"node",
"list"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/ext.py#L54-L75
|
ribozz/sphinx-argparse
|
sphinxarg/ext.py
|
print_action_groups
|
def print_action_groups(data, nested_content, markDownHelp=False, settings=None):
"""
Process all 'action groups', which are also include 'Options' and 'Required
arguments'. A list of nodes is returned.
"""
definitions = map_nested_definitions(nested_content)
nodes_list = []
if 'action_groups' in data:
for action_group in data['action_groups']:
# Every action group is comprised of a section, holding a title, the description, and the option group (members)
section = nodes.section(ids=[action_group['title']])
section += nodes.title(action_group['title'], action_group['title'])
desc = []
if action_group['description']:
desc.append(action_group['description'])
# Replace/append/prepend content to the description according to nested content
subContent = []
if action_group['title'] in definitions:
classifier, s, subContent = definitions[action_group['title']]
if classifier == '@replace':
desc = [s]
elif classifier == '@after':
desc.append(s)
elif classifier == '@before':
desc.insert(0, s)
elif classifier == '@skip':
continue
if len(subContent) > 0:
for k, v in map_nested_definitions(subContent).items():
definitions[k] = v
# Render appropriately
for element in renderList(desc, markDownHelp):
section += element
localDefinitions = definitions
if len(subContent) > 0:
localDefinitions = {k: v for k, v in definitions.items()}
for k, v in map_nested_definitions(subContent).items():
localDefinitions[k] = v
items = []
# Iterate over action group members
for entry in action_group['options']:
"""
Members will include:
default The default value. This may be ==SUPPRESS==
name A list of option names (e.g., ['-h', '--help']
help The help message string
There may also be a 'choices' member.
"""
# Build the help text
arg = []
if 'choices' in entry:
arg.append('Possible choices: {}\n'.format(", ".join([str(c) for c in entry['choices']])))
if 'help' in entry:
arg.append(entry['help'])
if entry['default'] is not None and entry['default'] not in ['"==SUPPRESS=="', '==SUPPRESS==']:
if entry['default'] == '':
arg.append('Default: ""')
else:
arg.append('Default: {}'.format(entry['default']))
# Handle nested content, the term used in the dict has the comma removed for simplicity
desc = arg
term = ' '.join(entry['name'])
if term in localDefinitions:
classifier, s, subContent = localDefinitions[term]
if classifier == '@replace':
desc = [s]
elif classifier == '@after':
desc.append(s)
elif classifier == '@before':
desc.insert(0, s)
term = ', '.join(entry['name'])
n = nodes.option_list_item('',
nodes.option_group('', nodes.option_string(text=term)),
nodes.description('', *renderList(desc, markDownHelp, settings)))
items.append(n)
section += nodes.option_list('', *items)
nodes_list.append(section)
return nodes_list
|
python
|
def print_action_groups(data, nested_content, markDownHelp=False, settings=None):
"""
Process all 'action groups', which are also include 'Options' and 'Required
arguments'. A list of nodes is returned.
"""
definitions = map_nested_definitions(nested_content)
nodes_list = []
if 'action_groups' in data:
for action_group in data['action_groups']:
# Every action group is comprised of a section, holding a title, the description, and the option group (members)
section = nodes.section(ids=[action_group['title']])
section += nodes.title(action_group['title'], action_group['title'])
desc = []
if action_group['description']:
desc.append(action_group['description'])
# Replace/append/prepend content to the description according to nested content
subContent = []
if action_group['title'] in definitions:
classifier, s, subContent = definitions[action_group['title']]
if classifier == '@replace':
desc = [s]
elif classifier == '@after':
desc.append(s)
elif classifier == '@before':
desc.insert(0, s)
elif classifier == '@skip':
continue
if len(subContent) > 0:
for k, v in map_nested_definitions(subContent).items():
definitions[k] = v
# Render appropriately
for element in renderList(desc, markDownHelp):
section += element
localDefinitions = definitions
if len(subContent) > 0:
localDefinitions = {k: v for k, v in definitions.items()}
for k, v in map_nested_definitions(subContent).items():
localDefinitions[k] = v
items = []
# Iterate over action group members
for entry in action_group['options']:
"""
Members will include:
default The default value. This may be ==SUPPRESS==
name A list of option names (e.g., ['-h', '--help']
help The help message string
There may also be a 'choices' member.
"""
# Build the help text
arg = []
if 'choices' in entry:
arg.append('Possible choices: {}\n'.format(", ".join([str(c) for c in entry['choices']])))
if 'help' in entry:
arg.append(entry['help'])
if entry['default'] is not None and entry['default'] not in ['"==SUPPRESS=="', '==SUPPRESS==']:
if entry['default'] == '':
arg.append('Default: ""')
else:
arg.append('Default: {}'.format(entry['default']))
# Handle nested content, the term used in the dict has the comma removed for simplicity
desc = arg
term = ' '.join(entry['name'])
if term in localDefinitions:
classifier, s, subContent = localDefinitions[term]
if classifier == '@replace':
desc = [s]
elif classifier == '@after':
desc.append(s)
elif classifier == '@before':
desc.insert(0, s)
term = ', '.join(entry['name'])
n = nodes.option_list_item('',
nodes.option_group('', nodes.option_string(text=term)),
nodes.description('', *renderList(desc, markDownHelp, settings)))
items.append(n)
section += nodes.option_list('', *items)
nodes_list.append(section)
return nodes_list
|
[
"def",
"print_action_groups",
"(",
"data",
",",
"nested_content",
",",
"markDownHelp",
"=",
"False",
",",
"settings",
"=",
"None",
")",
":",
"definitions",
"=",
"map_nested_definitions",
"(",
"nested_content",
")",
"nodes_list",
"=",
"[",
"]",
"if",
"'action_groups'",
"in",
"data",
":",
"for",
"action_group",
"in",
"data",
"[",
"'action_groups'",
"]",
":",
"# Every action group is comprised of a section, holding a title, the description, and the option group (members)",
"section",
"=",
"nodes",
".",
"section",
"(",
"ids",
"=",
"[",
"action_group",
"[",
"'title'",
"]",
"]",
")",
"section",
"+=",
"nodes",
".",
"title",
"(",
"action_group",
"[",
"'title'",
"]",
",",
"action_group",
"[",
"'title'",
"]",
")",
"desc",
"=",
"[",
"]",
"if",
"action_group",
"[",
"'description'",
"]",
":",
"desc",
".",
"append",
"(",
"action_group",
"[",
"'description'",
"]",
")",
"# Replace/append/prepend content to the description according to nested content",
"subContent",
"=",
"[",
"]",
"if",
"action_group",
"[",
"'title'",
"]",
"in",
"definitions",
":",
"classifier",
",",
"s",
",",
"subContent",
"=",
"definitions",
"[",
"action_group",
"[",
"'title'",
"]",
"]",
"if",
"classifier",
"==",
"'@replace'",
":",
"desc",
"=",
"[",
"s",
"]",
"elif",
"classifier",
"==",
"'@after'",
":",
"desc",
".",
"append",
"(",
"s",
")",
"elif",
"classifier",
"==",
"'@before'",
":",
"desc",
".",
"insert",
"(",
"0",
",",
"s",
")",
"elif",
"classifier",
"==",
"'@skip'",
":",
"continue",
"if",
"len",
"(",
"subContent",
")",
">",
"0",
":",
"for",
"k",
",",
"v",
"in",
"map_nested_definitions",
"(",
"subContent",
")",
".",
"items",
"(",
")",
":",
"definitions",
"[",
"k",
"]",
"=",
"v",
"# Render appropriately",
"for",
"element",
"in",
"renderList",
"(",
"desc",
",",
"markDownHelp",
")",
":",
"section",
"+=",
"element",
"localDefinitions",
"=",
"definitions",
"if",
"len",
"(",
"subContent",
")",
">",
"0",
":",
"localDefinitions",
"=",
"{",
"k",
":",
"v",
"for",
"k",
",",
"v",
"in",
"definitions",
".",
"items",
"(",
")",
"}",
"for",
"k",
",",
"v",
"in",
"map_nested_definitions",
"(",
"subContent",
")",
".",
"items",
"(",
")",
":",
"localDefinitions",
"[",
"k",
"]",
"=",
"v",
"items",
"=",
"[",
"]",
"# Iterate over action group members",
"for",
"entry",
"in",
"action_group",
"[",
"'options'",
"]",
":",
"\"\"\"\n Members will include:\n default\tThe default value. This may be ==SUPPRESS==\n name\tA list of option names (e.g., ['-h', '--help']\n help\tThe help message string\n There may also be a 'choices' member.\n \"\"\"",
"# Build the help text",
"arg",
"=",
"[",
"]",
"if",
"'choices'",
"in",
"entry",
":",
"arg",
".",
"append",
"(",
"'Possible choices: {}\\n'",
".",
"format",
"(",
"\", \"",
".",
"join",
"(",
"[",
"str",
"(",
"c",
")",
"for",
"c",
"in",
"entry",
"[",
"'choices'",
"]",
"]",
")",
")",
")",
"if",
"'help'",
"in",
"entry",
":",
"arg",
".",
"append",
"(",
"entry",
"[",
"'help'",
"]",
")",
"if",
"entry",
"[",
"'default'",
"]",
"is",
"not",
"None",
"and",
"entry",
"[",
"'default'",
"]",
"not",
"in",
"[",
"'\"==SUPPRESS==\"'",
",",
"'==SUPPRESS=='",
"]",
":",
"if",
"entry",
"[",
"'default'",
"]",
"==",
"''",
":",
"arg",
".",
"append",
"(",
"'Default: \"\"'",
")",
"else",
":",
"arg",
".",
"append",
"(",
"'Default: {}'",
".",
"format",
"(",
"entry",
"[",
"'default'",
"]",
")",
")",
"# Handle nested content, the term used in the dict has the comma removed for simplicity",
"desc",
"=",
"arg",
"term",
"=",
"' '",
".",
"join",
"(",
"entry",
"[",
"'name'",
"]",
")",
"if",
"term",
"in",
"localDefinitions",
":",
"classifier",
",",
"s",
",",
"subContent",
"=",
"localDefinitions",
"[",
"term",
"]",
"if",
"classifier",
"==",
"'@replace'",
":",
"desc",
"=",
"[",
"s",
"]",
"elif",
"classifier",
"==",
"'@after'",
":",
"desc",
".",
"append",
"(",
"s",
")",
"elif",
"classifier",
"==",
"'@before'",
":",
"desc",
".",
"insert",
"(",
"0",
",",
"s",
")",
"term",
"=",
"', '",
".",
"join",
"(",
"entry",
"[",
"'name'",
"]",
")",
"n",
"=",
"nodes",
".",
"option_list_item",
"(",
"''",
",",
"nodes",
".",
"option_group",
"(",
"''",
",",
"nodes",
".",
"option_string",
"(",
"text",
"=",
"term",
")",
")",
",",
"nodes",
".",
"description",
"(",
"''",
",",
"*",
"renderList",
"(",
"desc",
",",
"markDownHelp",
",",
"settings",
")",
")",
")",
"items",
".",
"append",
"(",
"n",
")",
"section",
"+=",
"nodes",
".",
"option_list",
"(",
"''",
",",
"*",
"items",
")",
"nodes_list",
".",
"append",
"(",
"section",
")",
"return",
"nodes_list"
] |
Process all 'action groups', which are also include 'Options' and 'Required
arguments'. A list of nodes is returned.
|
[
"Process",
"all",
"action",
"groups",
"which",
"are",
"also",
"include",
"Options",
"and",
"Required",
"arguments",
".",
"A",
"list",
"of",
"nodes",
"is",
"returned",
"."
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/ext.py#L78-L162
|
ribozz/sphinx-argparse
|
sphinxarg/ext.py
|
print_subcommands
|
def print_subcommands(data, nested_content, markDownHelp=False, settings=None):
"""
Each subcommand is a dictionary with the following keys:
['usage', 'action_groups', 'bare_usage', 'name', 'help']
In essence, this is all tossed in a new section with the title 'name'.
Apparently there can also be a 'description' entry.
"""
definitions = map_nested_definitions(nested_content)
items = []
if 'children' in data:
subCommands = nodes.section(ids=["Sub-commands:"])
subCommands += nodes.title('Sub-commands:', 'Sub-commands:')
for child in data['children']:
sec = nodes.section(ids=[child['name']])
sec += nodes.title(child['name'], child['name'])
if 'description' in child and child['description']:
desc = [child['description']]
elif child['help']:
desc = [child['help']]
else:
desc = ['Undocumented']
# Handle nested content
subContent = []
if child['name'] in definitions:
classifier, s, subContent = definitions[child['name']]
if classifier == '@replace':
desc = [s]
elif classifier == '@after':
desc.append(s)
elif classifier == '@before':
desc.insert(0, s)
for element in renderList(desc, markDownHelp):
sec += element
sec += nodes.literal_block(text=child['bare_usage'])
for x in print_action_groups(child, nested_content + subContent, markDownHelp,
settings=settings):
sec += x
for x in print_subcommands(child, nested_content + subContent, markDownHelp,
settings=settings):
sec += x
if 'epilog' in child and child['epilog']:
for element in renderList([child['epilog']], markDownHelp):
sec += element
subCommands += sec
items.append(subCommands)
return items
|
python
|
def print_subcommands(data, nested_content, markDownHelp=False, settings=None):
"""
Each subcommand is a dictionary with the following keys:
['usage', 'action_groups', 'bare_usage', 'name', 'help']
In essence, this is all tossed in a new section with the title 'name'.
Apparently there can also be a 'description' entry.
"""
definitions = map_nested_definitions(nested_content)
items = []
if 'children' in data:
subCommands = nodes.section(ids=["Sub-commands:"])
subCommands += nodes.title('Sub-commands:', 'Sub-commands:')
for child in data['children']:
sec = nodes.section(ids=[child['name']])
sec += nodes.title(child['name'], child['name'])
if 'description' in child and child['description']:
desc = [child['description']]
elif child['help']:
desc = [child['help']]
else:
desc = ['Undocumented']
# Handle nested content
subContent = []
if child['name'] in definitions:
classifier, s, subContent = definitions[child['name']]
if classifier == '@replace':
desc = [s]
elif classifier == '@after':
desc.append(s)
elif classifier == '@before':
desc.insert(0, s)
for element in renderList(desc, markDownHelp):
sec += element
sec += nodes.literal_block(text=child['bare_usage'])
for x in print_action_groups(child, nested_content + subContent, markDownHelp,
settings=settings):
sec += x
for x in print_subcommands(child, nested_content + subContent, markDownHelp,
settings=settings):
sec += x
if 'epilog' in child and child['epilog']:
for element in renderList([child['epilog']], markDownHelp):
sec += element
subCommands += sec
items.append(subCommands)
return items
|
[
"def",
"print_subcommands",
"(",
"data",
",",
"nested_content",
",",
"markDownHelp",
"=",
"False",
",",
"settings",
"=",
"None",
")",
":",
"definitions",
"=",
"map_nested_definitions",
"(",
"nested_content",
")",
"items",
"=",
"[",
"]",
"if",
"'children'",
"in",
"data",
":",
"subCommands",
"=",
"nodes",
".",
"section",
"(",
"ids",
"=",
"[",
"\"Sub-commands:\"",
"]",
")",
"subCommands",
"+=",
"nodes",
".",
"title",
"(",
"'Sub-commands:'",
",",
"'Sub-commands:'",
")",
"for",
"child",
"in",
"data",
"[",
"'children'",
"]",
":",
"sec",
"=",
"nodes",
".",
"section",
"(",
"ids",
"=",
"[",
"child",
"[",
"'name'",
"]",
"]",
")",
"sec",
"+=",
"nodes",
".",
"title",
"(",
"child",
"[",
"'name'",
"]",
",",
"child",
"[",
"'name'",
"]",
")",
"if",
"'description'",
"in",
"child",
"and",
"child",
"[",
"'description'",
"]",
":",
"desc",
"=",
"[",
"child",
"[",
"'description'",
"]",
"]",
"elif",
"child",
"[",
"'help'",
"]",
":",
"desc",
"=",
"[",
"child",
"[",
"'help'",
"]",
"]",
"else",
":",
"desc",
"=",
"[",
"'Undocumented'",
"]",
"# Handle nested content",
"subContent",
"=",
"[",
"]",
"if",
"child",
"[",
"'name'",
"]",
"in",
"definitions",
":",
"classifier",
",",
"s",
",",
"subContent",
"=",
"definitions",
"[",
"child",
"[",
"'name'",
"]",
"]",
"if",
"classifier",
"==",
"'@replace'",
":",
"desc",
"=",
"[",
"s",
"]",
"elif",
"classifier",
"==",
"'@after'",
":",
"desc",
".",
"append",
"(",
"s",
")",
"elif",
"classifier",
"==",
"'@before'",
":",
"desc",
".",
"insert",
"(",
"0",
",",
"s",
")",
"for",
"element",
"in",
"renderList",
"(",
"desc",
",",
"markDownHelp",
")",
":",
"sec",
"+=",
"element",
"sec",
"+=",
"nodes",
".",
"literal_block",
"(",
"text",
"=",
"child",
"[",
"'bare_usage'",
"]",
")",
"for",
"x",
"in",
"print_action_groups",
"(",
"child",
",",
"nested_content",
"+",
"subContent",
",",
"markDownHelp",
",",
"settings",
"=",
"settings",
")",
":",
"sec",
"+=",
"x",
"for",
"x",
"in",
"print_subcommands",
"(",
"child",
",",
"nested_content",
"+",
"subContent",
",",
"markDownHelp",
",",
"settings",
"=",
"settings",
")",
":",
"sec",
"+=",
"x",
"if",
"'epilog'",
"in",
"child",
"and",
"child",
"[",
"'epilog'",
"]",
":",
"for",
"element",
"in",
"renderList",
"(",
"[",
"child",
"[",
"'epilog'",
"]",
"]",
",",
"markDownHelp",
")",
":",
"sec",
"+=",
"element",
"subCommands",
"+=",
"sec",
"items",
".",
"append",
"(",
"subCommands",
")",
"return",
"items"
] |
Each subcommand is a dictionary with the following keys:
['usage', 'action_groups', 'bare_usage', 'name', 'help']
In essence, this is all tossed in a new section with the title 'name'.
Apparently there can also be a 'description' entry.
|
[
"Each",
"subcommand",
"is",
"a",
"dictionary",
"with",
"the",
"following",
"keys",
":"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/ext.py#L165-L221
|
ribozz/sphinx-argparse
|
sphinxarg/ext.py
|
ensureUniqueIDs
|
def ensureUniqueIDs(items):
"""
If action groups are repeated, then links in the table of contents will
just go to the first of the repeats. This may not be desirable, particularly
in the case of subcommands where the option groups have different members.
This function updates the title IDs by adding _repeatX, where X is a number
so that the links are then unique.
"""
s = set()
for item in items:
for n in item.traverse(descend=True, siblings=True, ascend=False):
if isinstance(n, nodes.section):
ids = n['ids']
for idx, id in enumerate(ids):
if id not in s:
s.add(id)
else:
i = 1
while "{}_repeat{}".format(id, i) in s:
i += 1
ids[idx] = "{}_repeat{}".format(id, i)
s.add(ids[idx])
n['ids'] = ids
|
python
|
def ensureUniqueIDs(items):
"""
If action groups are repeated, then links in the table of contents will
just go to the first of the repeats. This may not be desirable, particularly
in the case of subcommands where the option groups have different members.
This function updates the title IDs by adding _repeatX, where X is a number
so that the links are then unique.
"""
s = set()
for item in items:
for n in item.traverse(descend=True, siblings=True, ascend=False):
if isinstance(n, nodes.section):
ids = n['ids']
for idx, id in enumerate(ids):
if id not in s:
s.add(id)
else:
i = 1
while "{}_repeat{}".format(id, i) in s:
i += 1
ids[idx] = "{}_repeat{}".format(id, i)
s.add(ids[idx])
n['ids'] = ids
|
[
"def",
"ensureUniqueIDs",
"(",
"items",
")",
":",
"s",
"=",
"set",
"(",
")",
"for",
"item",
"in",
"items",
":",
"for",
"n",
"in",
"item",
".",
"traverse",
"(",
"descend",
"=",
"True",
",",
"siblings",
"=",
"True",
",",
"ascend",
"=",
"False",
")",
":",
"if",
"isinstance",
"(",
"n",
",",
"nodes",
".",
"section",
")",
":",
"ids",
"=",
"n",
"[",
"'ids'",
"]",
"for",
"idx",
",",
"id",
"in",
"enumerate",
"(",
"ids",
")",
":",
"if",
"id",
"not",
"in",
"s",
":",
"s",
".",
"add",
"(",
"id",
")",
"else",
":",
"i",
"=",
"1",
"while",
"\"{}_repeat{}\"",
".",
"format",
"(",
"id",
",",
"i",
")",
"in",
"s",
":",
"i",
"+=",
"1",
"ids",
"[",
"idx",
"]",
"=",
"\"{}_repeat{}\"",
".",
"format",
"(",
"id",
",",
"i",
")",
"s",
".",
"add",
"(",
"ids",
"[",
"idx",
"]",
")",
"n",
"[",
"'ids'",
"]",
"=",
"ids"
] |
If action groups are repeated, then links in the table of contents will
just go to the first of the repeats. This may not be desirable, particularly
in the case of subcommands where the option groups have different members.
This function updates the title IDs by adding _repeatX, where X is a number
so that the links are then unique.
|
[
"If",
"action",
"groups",
"are",
"repeated",
"then",
"links",
"in",
"the",
"table",
"of",
"contents",
"will",
"just",
"go",
"to",
"the",
"first",
"of",
"the",
"repeats",
".",
"This",
"may",
"not",
"be",
"desirable",
"particularly",
"in",
"the",
"case",
"of",
"subcommands",
"where",
"the",
"option",
"groups",
"have",
"different",
"members",
".",
"This",
"function",
"updates",
"the",
"title",
"IDs",
"by",
"adding",
"_repeatX",
"where",
"X",
"is",
"a",
"number",
"so",
"that",
"the",
"links",
"are",
"then",
"unique",
"."
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/ext.py#L224-L246
|
ribozz/sphinx-argparse
|
sphinxarg/ext.py
|
ArgParseDirective._construct_manpage_specific_structure
|
def _construct_manpage_specific_structure(self, parser_info):
"""
Construct a typical man page consisting of the following elements:
NAME (automatically generated, out of our control)
SYNOPSIS
DESCRIPTION
OPTIONS
FILES
SEE ALSO
BUGS
"""
items = []
# SYNOPSIS section
synopsis_section = nodes.section(
'',
nodes.title(text='Synopsis'),
nodes.literal_block(text=parser_info["bare_usage"]),
ids=['synopsis-section'])
items.append(synopsis_section)
# DESCRIPTION section
if 'nodescription' not in self.options:
description_section = nodes.section(
'',
nodes.title(text='Description'),
nodes.paragraph(text=parser_info.get(
'description', parser_info.get(
'help', "undocumented").capitalize())),
ids=['description-section'])
nested_parse_with_titles(
self.state, self.content, description_section)
items.append(description_section)
if parser_info.get('epilog') and 'noepilog' not in self.options:
# TODO: do whatever sphinx does to understand ReST inside
# docstrings magically imported from other places. The nested
# parse method invoked above seem to be able to do this but
# I haven't found a way to do it for arbitrary text
if description_section:
description_section += nodes.paragraph(
text=parser_info['epilog'])
else:
description_section = nodes.paragraph(
text=parser_info['epilog'])
items.append(description_section)
# OPTIONS section
options_section = nodes.section(
'',
nodes.title(text='Options'),
ids=['options-section'])
if 'args' in parser_info:
options_section += nodes.paragraph()
options_section += nodes.subtitle(text='Positional arguments:')
options_section += self._format_positional_arguments(parser_info)
for action_group in parser_info['action_groups']:
if 'options' in parser_info:
options_section += nodes.paragraph()
options_section += nodes.subtitle(text=action_group['title'])
options_section += self._format_optional_arguments(action_group)
# NOTE: we cannot generate NAME ourselves. It is generated by
# docutils.writers.manpage
# TODO: items.append(files)
# TODO: items.append(see also)
# TODO: items.append(bugs)
if len(options_section.children) > 1:
items.append(options_section)
if 'nosubcommands' not in self.options:
# SUBCOMMANDS section (non-standard)
subcommands_section = nodes.section(
'',
nodes.title(text='Sub-Commands'),
ids=['subcommands-section'])
if 'children' in parser_info:
subcommands_section += self._format_subcommands(parser_info)
if len(subcommands_section) > 1:
items.append(subcommands_section)
if os.getenv("INCLUDE_DEBUG_SECTION"):
import json
# DEBUG section (non-standard)
debug_section = nodes.section(
'',
nodes.title(text="Argparse + Sphinx Debugging"),
nodes.literal_block(text=json.dumps(parser_info, indent=' ')),
ids=['debug-section'])
items.append(debug_section)
return items
|
python
|
def _construct_manpage_specific_structure(self, parser_info):
"""
Construct a typical man page consisting of the following elements:
NAME (automatically generated, out of our control)
SYNOPSIS
DESCRIPTION
OPTIONS
FILES
SEE ALSO
BUGS
"""
items = []
# SYNOPSIS section
synopsis_section = nodes.section(
'',
nodes.title(text='Synopsis'),
nodes.literal_block(text=parser_info["bare_usage"]),
ids=['synopsis-section'])
items.append(synopsis_section)
# DESCRIPTION section
if 'nodescription' not in self.options:
description_section = nodes.section(
'',
nodes.title(text='Description'),
nodes.paragraph(text=parser_info.get(
'description', parser_info.get(
'help', "undocumented").capitalize())),
ids=['description-section'])
nested_parse_with_titles(
self.state, self.content, description_section)
items.append(description_section)
if parser_info.get('epilog') and 'noepilog' not in self.options:
# TODO: do whatever sphinx does to understand ReST inside
# docstrings magically imported from other places. The nested
# parse method invoked above seem to be able to do this but
# I haven't found a way to do it for arbitrary text
if description_section:
description_section += nodes.paragraph(
text=parser_info['epilog'])
else:
description_section = nodes.paragraph(
text=parser_info['epilog'])
items.append(description_section)
# OPTIONS section
options_section = nodes.section(
'',
nodes.title(text='Options'),
ids=['options-section'])
if 'args' in parser_info:
options_section += nodes.paragraph()
options_section += nodes.subtitle(text='Positional arguments:')
options_section += self._format_positional_arguments(parser_info)
for action_group in parser_info['action_groups']:
if 'options' in parser_info:
options_section += nodes.paragraph()
options_section += nodes.subtitle(text=action_group['title'])
options_section += self._format_optional_arguments(action_group)
# NOTE: we cannot generate NAME ourselves. It is generated by
# docutils.writers.manpage
# TODO: items.append(files)
# TODO: items.append(see also)
# TODO: items.append(bugs)
if len(options_section.children) > 1:
items.append(options_section)
if 'nosubcommands' not in self.options:
# SUBCOMMANDS section (non-standard)
subcommands_section = nodes.section(
'',
nodes.title(text='Sub-Commands'),
ids=['subcommands-section'])
if 'children' in parser_info:
subcommands_section += self._format_subcommands(parser_info)
if len(subcommands_section) > 1:
items.append(subcommands_section)
if os.getenv("INCLUDE_DEBUG_SECTION"):
import json
# DEBUG section (non-standard)
debug_section = nodes.section(
'',
nodes.title(text="Argparse + Sphinx Debugging"),
nodes.literal_block(text=json.dumps(parser_info, indent=' ')),
ids=['debug-section'])
items.append(debug_section)
return items
|
[
"def",
"_construct_manpage_specific_structure",
"(",
"self",
",",
"parser_info",
")",
":",
"items",
"=",
"[",
"]",
"# SYNOPSIS section",
"synopsis_section",
"=",
"nodes",
".",
"section",
"(",
"''",
",",
"nodes",
".",
"title",
"(",
"text",
"=",
"'Synopsis'",
")",
",",
"nodes",
".",
"literal_block",
"(",
"text",
"=",
"parser_info",
"[",
"\"bare_usage\"",
"]",
")",
",",
"ids",
"=",
"[",
"'synopsis-section'",
"]",
")",
"items",
".",
"append",
"(",
"synopsis_section",
")",
"# DESCRIPTION section",
"if",
"'nodescription'",
"not",
"in",
"self",
".",
"options",
":",
"description_section",
"=",
"nodes",
".",
"section",
"(",
"''",
",",
"nodes",
".",
"title",
"(",
"text",
"=",
"'Description'",
")",
",",
"nodes",
".",
"paragraph",
"(",
"text",
"=",
"parser_info",
".",
"get",
"(",
"'description'",
",",
"parser_info",
".",
"get",
"(",
"'help'",
",",
"\"undocumented\"",
")",
".",
"capitalize",
"(",
")",
")",
")",
",",
"ids",
"=",
"[",
"'description-section'",
"]",
")",
"nested_parse_with_titles",
"(",
"self",
".",
"state",
",",
"self",
".",
"content",
",",
"description_section",
")",
"items",
".",
"append",
"(",
"description_section",
")",
"if",
"parser_info",
".",
"get",
"(",
"'epilog'",
")",
"and",
"'noepilog'",
"not",
"in",
"self",
".",
"options",
":",
"# TODO: do whatever sphinx does to understand ReST inside",
"# docstrings magically imported from other places. The nested",
"# parse method invoked above seem to be able to do this but",
"# I haven't found a way to do it for arbitrary text",
"if",
"description_section",
":",
"description_section",
"+=",
"nodes",
".",
"paragraph",
"(",
"text",
"=",
"parser_info",
"[",
"'epilog'",
"]",
")",
"else",
":",
"description_section",
"=",
"nodes",
".",
"paragraph",
"(",
"text",
"=",
"parser_info",
"[",
"'epilog'",
"]",
")",
"items",
".",
"append",
"(",
"description_section",
")",
"# OPTIONS section",
"options_section",
"=",
"nodes",
".",
"section",
"(",
"''",
",",
"nodes",
".",
"title",
"(",
"text",
"=",
"'Options'",
")",
",",
"ids",
"=",
"[",
"'options-section'",
"]",
")",
"if",
"'args'",
"in",
"parser_info",
":",
"options_section",
"+=",
"nodes",
".",
"paragraph",
"(",
")",
"options_section",
"+=",
"nodes",
".",
"subtitle",
"(",
"text",
"=",
"'Positional arguments:'",
")",
"options_section",
"+=",
"self",
".",
"_format_positional_arguments",
"(",
"parser_info",
")",
"for",
"action_group",
"in",
"parser_info",
"[",
"'action_groups'",
"]",
":",
"if",
"'options'",
"in",
"parser_info",
":",
"options_section",
"+=",
"nodes",
".",
"paragraph",
"(",
")",
"options_section",
"+=",
"nodes",
".",
"subtitle",
"(",
"text",
"=",
"action_group",
"[",
"'title'",
"]",
")",
"options_section",
"+=",
"self",
".",
"_format_optional_arguments",
"(",
"action_group",
")",
"# NOTE: we cannot generate NAME ourselves. It is generated by",
"# docutils.writers.manpage",
"# TODO: items.append(files)",
"# TODO: items.append(see also)",
"# TODO: items.append(bugs)",
"if",
"len",
"(",
"options_section",
".",
"children",
")",
">",
"1",
":",
"items",
".",
"append",
"(",
"options_section",
")",
"if",
"'nosubcommands'",
"not",
"in",
"self",
".",
"options",
":",
"# SUBCOMMANDS section (non-standard)",
"subcommands_section",
"=",
"nodes",
".",
"section",
"(",
"''",
",",
"nodes",
".",
"title",
"(",
"text",
"=",
"'Sub-Commands'",
")",
",",
"ids",
"=",
"[",
"'subcommands-section'",
"]",
")",
"if",
"'children'",
"in",
"parser_info",
":",
"subcommands_section",
"+=",
"self",
".",
"_format_subcommands",
"(",
"parser_info",
")",
"if",
"len",
"(",
"subcommands_section",
")",
">",
"1",
":",
"items",
".",
"append",
"(",
"subcommands_section",
")",
"if",
"os",
".",
"getenv",
"(",
"\"INCLUDE_DEBUG_SECTION\"",
")",
":",
"import",
"json",
"# DEBUG section (non-standard)",
"debug_section",
"=",
"nodes",
".",
"section",
"(",
"''",
",",
"nodes",
".",
"title",
"(",
"text",
"=",
"\"Argparse + Sphinx Debugging\"",
")",
",",
"nodes",
".",
"literal_block",
"(",
"text",
"=",
"json",
".",
"dumps",
"(",
"parser_info",
",",
"indent",
"=",
"' '",
")",
")",
",",
"ids",
"=",
"[",
"'debug-section'",
"]",
")",
"items",
".",
"append",
"(",
"debug_section",
")",
"return",
"items"
] |
Construct a typical man page consisting of the following elements:
NAME (automatically generated, out of our control)
SYNOPSIS
DESCRIPTION
OPTIONS
FILES
SEE ALSO
BUGS
|
[
"Construct",
"a",
"typical",
"man",
"page",
"consisting",
"of",
"the",
"following",
"elements",
":",
"NAME",
"(",
"automatically",
"generated",
"out",
"of",
"our",
"control",
")",
"SYNOPSIS",
"DESCRIPTION",
"OPTIONS",
"FILES",
"SEE",
"ALSO",
"BUGS"
] |
train
|
https://github.com/ribozz/sphinx-argparse/blob/178672cd5c846440ff7ecd695e3708feea13e4b4/sphinxarg/ext.py#L258-L343
|
ddorn/GUI
|
GUI/vracabulous.py
|
FocusSelector.select
|
def select(self, item):
"""Select an arbitrary item, by possition or by reference."""
self._on_unselect[self._selected]()
self.selected().unfocus()
if isinstance(item, int):
self._selected = item % len(self)
else:
self._selected = self.items.index(item)
self.selected().focus()
self._on_select[self._selected]()
|
python
|
def select(self, item):
"""Select an arbitrary item, by possition or by reference."""
self._on_unselect[self._selected]()
self.selected().unfocus()
if isinstance(item, int):
self._selected = item % len(self)
else:
self._selected = self.items.index(item)
self.selected().focus()
self._on_select[self._selected]()
|
[
"def",
"select",
"(",
"self",
",",
"item",
")",
":",
"self",
".",
"_on_unselect",
"[",
"self",
".",
"_selected",
"]",
"(",
")",
"self",
".",
"selected",
"(",
")",
".",
"unfocus",
"(",
")",
"if",
"isinstance",
"(",
"item",
",",
"int",
")",
":",
"self",
".",
"_selected",
"=",
"item",
"%",
"len",
"(",
"self",
")",
"else",
":",
"self",
".",
"_selected",
"=",
"self",
".",
"items",
".",
"index",
"(",
"item",
")",
"self",
".",
"selected",
"(",
")",
".",
"focus",
"(",
")",
"self",
".",
"_on_select",
"[",
"self",
".",
"_selected",
"]",
"(",
")"
] |
Select an arbitrary item, by possition or by reference.
|
[
"Select",
"an",
"arbitrary",
"item",
"by",
"possition",
"or",
"by",
"reference",
"."
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/vracabulous.py#L71-L82
|
ddorn/GUI
|
GUI/vracabulous.py
|
FocusSelector.on_select
|
def on_select(self, item, action):
"""
Add an action to make when an object is selected.
Only one action can be stored this way.
"""
if not isinstance(item, int):
item = self.items.index(item)
self._on_select[item] = action
|
python
|
def on_select(self, item, action):
"""
Add an action to make when an object is selected.
Only one action can be stored this way.
"""
if not isinstance(item, int):
item = self.items.index(item)
self._on_select[item] = action
|
[
"def",
"on_select",
"(",
"self",
",",
"item",
",",
"action",
")",
":",
"if",
"not",
"isinstance",
"(",
"item",
",",
"int",
")",
":",
"item",
"=",
"self",
".",
"items",
".",
"index",
"(",
"item",
")",
"self",
".",
"_on_select",
"[",
"item",
"]",
"=",
"action"
] |
Add an action to make when an object is selected.
Only one action can be stored this way.
|
[
"Add",
"an",
"action",
"to",
"make",
"when",
"an",
"object",
"is",
"selected",
".",
"Only",
"one",
"action",
"can",
"be",
"stored",
"this",
"way",
"."
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/vracabulous.py#L96-L105
|
ddorn/GUI
|
GUI/vracabulous.py
|
FocusSelector.on_unselect
|
def on_unselect(self, item, action):
"""Add an action to make when an object is unfocused."""
if not isinstance(item, int):
item = self.items.index(item)
self._on_unselect[item] = action
|
python
|
def on_unselect(self, item, action):
"""Add an action to make when an object is unfocused."""
if not isinstance(item, int):
item = self.items.index(item)
self._on_unselect[item] = action
|
[
"def",
"on_unselect",
"(",
"self",
",",
"item",
",",
"action",
")",
":",
"if",
"not",
"isinstance",
"(",
"item",
",",
"int",
")",
":",
"item",
"=",
"self",
".",
"items",
".",
"index",
"(",
"item",
")",
"self",
".",
"_on_unselect",
"[",
"item",
"]",
"=",
"action"
] |
Add an action to make when an object is unfocused.
|
[
"Add",
"an",
"action",
"to",
"make",
"when",
"an",
"object",
"is",
"unfocused",
"."
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/vracabulous.py#L107-L112
|
ddorn/GUI
|
GUI/vracabulous.py
|
Window.add
|
def add(self, widget, condition=lambda: 42):
"""
Add a widget to the widows.
The widget will auto render. You can use the function like that if you want to keep the widget accecible :
self.my_widget = self.add(my_widget)
"""
assert callable(condition)
assert isinstance(widget, BaseWidget)
self._widgets.append((widget, condition))
return widget
|
python
|
def add(self, widget, condition=lambda: 42):
"""
Add a widget to the widows.
The widget will auto render. You can use the function like that if you want to keep the widget accecible :
self.my_widget = self.add(my_widget)
"""
assert callable(condition)
assert isinstance(widget, BaseWidget)
self._widgets.append((widget, condition))
return widget
|
[
"def",
"add",
"(",
"self",
",",
"widget",
",",
"condition",
"=",
"lambda",
":",
"42",
")",
":",
"assert",
"callable",
"(",
"condition",
")",
"assert",
"isinstance",
"(",
"widget",
",",
"BaseWidget",
")",
"self",
".",
"_widgets",
".",
"append",
"(",
"(",
"widget",
",",
"condition",
")",
")",
"return",
"widget"
] |
Add a widget to the widows.
The widget will auto render. You can use the function like that if you want to keep the widget accecible :
self.my_widget = self.add(my_widget)
|
[
"Add",
"a",
"widget",
"to",
"the",
"widows",
"."
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/vracabulous.py#L228-L240
|
ddorn/GUI
|
GUI/vracabulous.py
|
Window.remove
|
def remove(self, widget):
"""Remove a widget from the window."""
for i, (wid, _) in enumerate(self._widgets):
if widget is wid:
del self._widgets[i]
return True
raise ValueError('Widget not in list')
|
python
|
def remove(self, widget):
"""Remove a widget from the window."""
for i, (wid, _) in enumerate(self._widgets):
if widget is wid:
del self._widgets[i]
return True
raise ValueError('Widget not in list')
|
[
"def",
"remove",
"(",
"self",
",",
"widget",
")",
":",
"for",
"i",
",",
"(",
"wid",
",",
"_",
")",
"in",
"enumerate",
"(",
"self",
".",
"_widgets",
")",
":",
"if",
"widget",
"is",
"wid",
":",
"del",
"self",
".",
"_widgets",
"[",
"i",
"]",
"return",
"True",
"raise",
"ValueError",
"(",
"'Widget not in list'",
")"
] |
Remove a widget from the window.
|
[
"Remove",
"a",
"widget",
"from",
"the",
"window",
"."
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/vracabulous.py#L242-L249
|
ddorn/GUI
|
GUI/vracabulous.py
|
Window.update_on_event
|
def update_on_event(self, e):
"""Process a single event."""
if e.type == QUIT:
self.running = False
elif e.type == KEYDOWN:
if e.key == K_ESCAPE:
self.running = False
elif e.key == K_F4 and e.mod & KMOD_ALT: # Alt+F4 --> quits
self.running = False
elif e.type == VIDEORESIZE:
self.SCREEN_SIZE = e.size
self.screen = self.new_screen()
|
python
|
def update_on_event(self, e):
"""Process a single event."""
if e.type == QUIT:
self.running = False
elif e.type == KEYDOWN:
if e.key == K_ESCAPE:
self.running = False
elif e.key == K_F4 and e.mod & KMOD_ALT: # Alt+F4 --> quits
self.running = False
elif e.type == VIDEORESIZE:
self.SCREEN_SIZE = e.size
self.screen = self.new_screen()
|
[
"def",
"update_on_event",
"(",
"self",
",",
"e",
")",
":",
"if",
"e",
".",
"type",
"==",
"QUIT",
":",
"self",
".",
"running",
"=",
"False",
"elif",
"e",
".",
"type",
"==",
"KEYDOWN",
":",
"if",
"e",
".",
"key",
"==",
"K_ESCAPE",
":",
"self",
".",
"running",
"=",
"False",
"elif",
"e",
".",
"key",
"==",
"K_F4",
"and",
"e",
".",
"mod",
"&",
"KMOD_ALT",
":",
"# Alt+F4 --> quits",
"self",
".",
"running",
"=",
"False",
"elif",
"e",
".",
"type",
"==",
"VIDEORESIZE",
":",
"self",
".",
"SCREEN_SIZE",
"=",
"e",
".",
"size",
"self",
".",
"screen",
"=",
"self",
".",
"new_screen",
"(",
")"
] |
Process a single event.
|
[
"Process",
"a",
"single",
"event",
"."
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/vracabulous.py#L251-L265
|
ddorn/GUI
|
GUI/vracabulous.py
|
Window.update
|
def update(self):
"""Get all events and process them by calling update_on_event()"""
events = pygame.event.get()
for e in events:
self.update_on_event(e)
for wid, cond in self._widgets:
if cond():
wid.update(events)
|
python
|
def update(self):
"""Get all events and process them by calling update_on_event()"""
events = pygame.event.get()
for e in events:
self.update_on_event(e)
for wid, cond in self._widgets:
if cond():
wid.update(events)
|
[
"def",
"update",
"(",
"self",
")",
":",
"events",
"=",
"pygame",
".",
"event",
".",
"get",
"(",
")",
"for",
"e",
"in",
"events",
":",
"self",
".",
"update_on_event",
"(",
"e",
")",
"for",
"wid",
",",
"cond",
"in",
"self",
".",
"_widgets",
":",
"if",
"cond",
"(",
")",
":",
"wid",
".",
"update",
"(",
"events",
")"
] |
Get all events and process them by calling update_on_event()
|
[
"Get",
"all",
"events",
"and",
"process",
"them",
"by",
"calling",
"update_on_event",
"()"
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/vracabulous.py#L267-L275
|
ddorn/GUI
|
GUI/vracabulous.py
|
Window.render
|
def render(self):
"""Render the screen. Here you must draw everything."""
self.screen.fill(self.BACKGROUND_COLOR)
for wid, cond in self._widgets:
if cond():
wid.render(self.screen)
if self.BORDER_COLOR is not None:
pygame.draw.rect(self.screen, self.BORDER_COLOR, ((0, 0), self.SCREEN_SIZE), 1)
if self.SHOW_FPS:
self.fps.render(self.screen)
|
python
|
def render(self):
"""Render the screen. Here you must draw everything."""
self.screen.fill(self.BACKGROUND_COLOR)
for wid, cond in self._widgets:
if cond():
wid.render(self.screen)
if self.BORDER_COLOR is not None:
pygame.draw.rect(self.screen, self.BORDER_COLOR, ((0, 0), self.SCREEN_SIZE), 1)
if self.SHOW_FPS:
self.fps.render(self.screen)
|
[
"def",
"render",
"(",
"self",
")",
":",
"self",
".",
"screen",
".",
"fill",
"(",
"self",
".",
"BACKGROUND_COLOR",
")",
"for",
"wid",
",",
"cond",
"in",
"self",
".",
"_widgets",
":",
"if",
"cond",
"(",
")",
":",
"wid",
".",
"render",
"(",
"self",
".",
"screen",
")",
"if",
"self",
".",
"BORDER_COLOR",
"is",
"not",
"None",
":",
"pygame",
".",
"draw",
".",
"rect",
"(",
"self",
".",
"screen",
",",
"self",
".",
"BORDER_COLOR",
",",
"(",
"(",
"0",
",",
"0",
")",
",",
"self",
".",
"SCREEN_SIZE",
")",
",",
"1",
")",
"if",
"self",
".",
"SHOW_FPS",
":",
"self",
".",
"fps",
".",
"render",
"(",
"self",
".",
"screen",
")"
] |
Render the screen. Here you must draw everything.
|
[
"Render",
"the",
"screen",
".",
"Here",
"you",
"must",
"draw",
"everything",
"."
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/vracabulous.py#L277-L289
|
ddorn/GUI
|
GUI/vracabulous.py
|
Window.update_screen
|
def update_screen(self):
"""Refresh the screen. You don't need to override this except to update only small portins of the screen."""
self.clock.tick(self.FPS)
pygame.display.update()
|
python
|
def update_screen(self):
"""Refresh the screen. You don't need to override this except to update only small portins of the screen."""
self.clock.tick(self.FPS)
pygame.display.update()
|
[
"def",
"update_screen",
"(",
"self",
")",
":",
"self",
".",
"clock",
".",
"tick",
"(",
"self",
".",
"FPS",
")",
"pygame",
".",
"display",
".",
"update",
"(",
")"
] |
Refresh the screen. You don't need to override this except to update only small portins of the screen.
|
[
"Refresh",
"the",
"screen",
".",
"You",
"don",
"t",
"need",
"to",
"override",
"this",
"except",
"to",
"update",
"only",
"small",
"portins",
"of",
"the",
"screen",
"."
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/vracabulous.py#L292-L295
|
ddorn/GUI
|
GUI/vracabulous.py
|
Window.run
|
def run(self):
"""The run loop. Returns self.destroy()"""
while self.running:
self.update()
self.render()
self.update_screen()
return self.destroy()
|
python
|
def run(self):
"""The run loop. Returns self.destroy()"""
while self.running:
self.update()
self.render()
self.update_screen()
return self.destroy()
|
[
"def",
"run",
"(",
"self",
")",
":",
"while",
"self",
".",
"running",
":",
"self",
".",
"update",
"(",
")",
"self",
".",
"render",
"(",
")",
"self",
".",
"update_screen",
"(",
")",
"return",
"self",
".",
"destroy",
"(",
")"
] |
The run loop. Returns self.destroy()
|
[
"The",
"run",
"loop",
".",
"Returns",
"self",
".",
"destroy",
"()"
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/vracabulous.py#L302-L309
|
ddorn/GUI
|
GUI/vracabulous.py
|
Window.new_screen
|
def new_screen(self):
"""Makes a new screen with a size of SCREEN_SIZE, and VIDEO_OPTION as flags. Sets the windows name to NAME."""
os.environ['SDL_VIDEO_CENTERED'] = '1'
pygame.display.set_caption(self.NAME)
screen_s = self.SCREEN_SIZE
video_options = self.VIDEO_OPTIONS
if FULLSCREEN & self.VIDEO_OPTIONS:
video_options ^= FULLSCREEN
video_options |= NOFRAME
screen_s = (0, 0)
screen = pygame.display.set_mode(screen_s, video_options)
if FULLSCREEN & self.VIDEO_OPTIONS:
self.SCREEN_SIZE = screen.get_size()
if not QUIT in self.EVENT_ALLOWED:
self.EVENT_ALLOWED = list(self.EVENT_ALLOWED)
self.EVENT_ALLOWED.append(QUIT)
pygame.event.set_allowed(self.EVENT_ALLOWED)
return screen
|
python
|
def new_screen(self):
"""Makes a new screen with a size of SCREEN_SIZE, and VIDEO_OPTION as flags. Sets the windows name to NAME."""
os.environ['SDL_VIDEO_CENTERED'] = '1'
pygame.display.set_caption(self.NAME)
screen_s = self.SCREEN_SIZE
video_options = self.VIDEO_OPTIONS
if FULLSCREEN & self.VIDEO_OPTIONS:
video_options ^= FULLSCREEN
video_options |= NOFRAME
screen_s = (0, 0)
screen = pygame.display.set_mode(screen_s, video_options)
if FULLSCREEN & self.VIDEO_OPTIONS:
self.SCREEN_SIZE = screen.get_size()
if not QUIT in self.EVENT_ALLOWED:
self.EVENT_ALLOWED = list(self.EVENT_ALLOWED)
self.EVENT_ALLOWED.append(QUIT)
pygame.event.set_allowed(self.EVENT_ALLOWED)
return screen
|
[
"def",
"new_screen",
"(",
"self",
")",
":",
"os",
".",
"environ",
"[",
"'SDL_VIDEO_CENTERED'",
"]",
"=",
"'1'",
"pygame",
".",
"display",
".",
"set_caption",
"(",
"self",
".",
"NAME",
")",
"screen_s",
"=",
"self",
".",
"SCREEN_SIZE",
"video_options",
"=",
"self",
".",
"VIDEO_OPTIONS",
"if",
"FULLSCREEN",
"&",
"self",
".",
"VIDEO_OPTIONS",
":",
"video_options",
"^=",
"FULLSCREEN",
"video_options",
"|=",
"NOFRAME",
"screen_s",
"=",
"(",
"0",
",",
"0",
")",
"screen",
"=",
"pygame",
".",
"display",
".",
"set_mode",
"(",
"screen_s",
",",
"video_options",
")",
"if",
"FULLSCREEN",
"&",
"self",
".",
"VIDEO_OPTIONS",
":",
"self",
".",
"SCREEN_SIZE",
"=",
"screen",
".",
"get_size",
"(",
")",
"if",
"not",
"QUIT",
"in",
"self",
".",
"EVENT_ALLOWED",
":",
"self",
".",
"EVENT_ALLOWED",
"=",
"list",
"(",
"self",
".",
"EVENT_ALLOWED",
")",
"self",
".",
"EVENT_ALLOWED",
".",
"append",
"(",
"QUIT",
")",
"pygame",
".",
"event",
".",
"set_allowed",
"(",
"self",
".",
"EVENT_ALLOWED",
")",
"return",
"screen"
] |
Makes a new screen with a size of SCREEN_SIZE, and VIDEO_OPTION as flags. Sets the windows name to NAME.
|
[
"Makes",
"a",
"new",
"screen",
"with",
"a",
"size",
"of",
"SCREEN_SIZE",
"and",
"VIDEO_OPTION",
"as",
"flags",
".",
"Sets",
"the",
"windows",
"name",
"to",
"NAME",
"."
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/vracabulous.py#L311-L334
|
ddorn/GUI
|
GUI/math.py
|
merge_rects
|
def merge_rects(rect1, rect2):
"""Return the smallest rect containning two rects"""
r = pygame.Rect(rect1)
t = pygame.Rect(rect2)
right = max(r.right, t.right)
bot = max(r.bottom, t.bottom)
x = min(t.x, r.x)
y = min(t.y, r.y)
return pygame.Rect(x, y, right - x, bot - y)
|
python
|
def merge_rects(rect1, rect2):
"""Return the smallest rect containning two rects"""
r = pygame.Rect(rect1)
t = pygame.Rect(rect2)
right = max(r.right, t.right)
bot = max(r.bottom, t.bottom)
x = min(t.x, r.x)
y = min(t.y, r.y)
return pygame.Rect(x, y, right - x, bot - y)
|
[
"def",
"merge_rects",
"(",
"rect1",
",",
"rect2",
")",
":",
"r",
"=",
"pygame",
".",
"Rect",
"(",
"rect1",
")",
"t",
"=",
"pygame",
".",
"Rect",
"(",
"rect2",
")",
"right",
"=",
"max",
"(",
"r",
".",
"right",
",",
"t",
".",
"right",
")",
"bot",
"=",
"max",
"(",
"r",
".",
"bottom",
",",
"t",
".",
"bottom",
")",
"x",
"=",
"min",
"(",
"t",
".",
"x",
",",
"r",
".",
"x",
")",
"y",
"=",
"min",
"(",
"t",
".",
"y",
",",
"r",
".",
"y",
")",
"return",
"pygame",
".",
"Rect",
"(",
"x",
",",
"y",
",",
"right",
"-",
"x",
",",
"bot",
"-",
"y",
")"
] |
Return the smallest rect containning two rects
|
[
"Return",
"the",
"smallest",
"rect",
"containning",
"two",
"rects"
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/math.py#L18-L28
|
ddorn/GUI
|
GUI/math.py
|
V2.normnorm
|
def normnorm(self):
"""
Return a vecor noraml to this one with a norm of one
:return: V2
"""
n = self.norm()
return V2(-self.y / n, self.x / n)
|
python
|
def normnorm(self):
"""
Return a vecor noraml to this one with a norm of one
:return: V2
"""
n = self.norm()
return V2(-self.y / n, self.x / n)
|
[
"def",
"normnorm",
"(",
"self",
")",
":",
"n",
"=",
"self",
".",
"norm",
"(",
")",
"return",
"V2",
"(",
"-",
"self",
".",
"y",
"/",
"n",
",",
"self",
".",
"x",
"/",
"n",
")"
] |
Return a vecor noraml to this one with a norm of one
:return: V2
|
[
"Return",
"a",
"vecor",
"noraml",
"to",
"this",
"one",
"with",
"a",
"norm",
"of",
"one"
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/math.py#L109-L117
|
ddorn/GUI
|
GUI/draw.py
|
line
|
def line(surf, start, end, color=BLACK, width=1, style=FLAT):
"""Draws an antialiased line on the surface."""
width = round(width, 1)
if width == 1:
# return pygame.draw.aaline(surf, color, start, end)
return gfxdraw.line(surf, *start, *end, color)
start = V2(*start)
end = V2(*end)
line_vector = end - start
half_side = line_vector.normnorm() * width / 2
point1 = start + half_side
point2 = start - half_side
point3 = end - half_side
point4 = end + half_side
# noinspection PyUnresolvedReferences
liste = [
(point1.x, point1.y),
(point2.x, point2.y),
(point3.x, point3.y),
(point4.x, point4.y)
]
rect = polygon(surf, liste, color)
if style == ROUNDED:
_ = circle(surf, start, width / 2, color)
rect = merge_rects(rect, _)
_ = circle(surf, end, width / 2, color)
rect = merge_rects(rect, _)
return rect
|
python
|
def line(surf, start, end, color=BLACK, width=1, style=FLAT):
"""Draws an antialiased line on the surface."""
width = round(width, 1)
if width == 1:
# return pygame.draw.aaline(surf, color, start, end)
return gfxdraw.line(surf, *start, *end, color)
start = V2(*start)
end = V2(*end)
line_vector = end - start
half_side = line_vector.normnorm() * width / 2
point1 = start + half_side
point2 = start - half_side
point3 = end - half_side
point4 = end + half_side
# noinspection PyUnresolvedReferences
liste = [
(point1.x, point1.y),
(point2.x, point2.y),
(point3.x, point3.y),
(point4.x, point4.y)
]
rect = polygon(surf, liste, color)
if style == ROUNDED:
_ = circle(surf, start, width / 2, color)
rect = merge_rects(rect, _)
_ = circle(surf, end, width / 2, color)
rect = merge_rects(rect, _)
return rect
|
[
"def",
"line",
"(",
"surf",
",",
"start",
",",
"end",
",",
"color",
"=",
"BLACK",
",",
"width",
"=",
"1",
",",
"style",
"=",
"FLAT",
")",
":",
"width",
"=",
"round",
"(",
"width",
",",
"1",
")",
"if",
"width",
"==",
"1",
":",
"# return pygame.draw.aaline(surf, color, start, end)",
"return",
"gfxdraw",
".",
"line",
"(",
"surf",
",",
"*",
"start",
",",
"*",
"end",
",",
"color",
")",
"start",
"=",
"V2",
"(",
"*",
"start",
")",
"end",
"=",
"V2",
"(",
"*",
"end",
")",
"line_vector",
"=",
"end",
"-",
"start",
"half_side",
"=",
"line_vector",
".",
"normnorm",
"(",
")",
"*",
"width",
"/",
"2",
"point1",
"=",
"start",
"+",
"half_side",
"point2",
"=",
"start",
"-",
"half_side",
"point3",
"=",
"end",
"-",
"half_side",
"point4",
"=",
"end",
"+",
"half_side",
"# noinspection PyUnresolvedReferences",
"liste",
"=",
"[",
"(",
"point1",
".",
"x",
",",
"point1",
".",
"y",
")",
",",
"(",
"point2",
".",
"x",
",",
"point2",
".",
"y",
")",
",",
"(",
"point3",
".",
"x",
",",
"point3",
".",
"y",
")",
",",
"(",
"point4",
".",
"x",
",",
"point4",
".",
"y",
")",
"]",
"rect",
"=",
"polygon",
"(",
"surf",
",",
"liste",
",",
"color",
")",
"if",
"style",
"==",
"ROUNDED",
":",
"_",
"=",
"circle",
"(",
"surf",
",",
"start",
",",
"width",
"/",
"2",
",",
"color",
")",
"rect",
"=",
"merge_rects",
"(",
"rect",
",",
"_",
")",
"_",
"=",
"circle",
"(",
"surf",
",",
"end",
",",
"width",
"/",
"2",
",",
"color",
")",
"rect",
"=",
"merge_rects",
"(",
"rect",
",",
"_",
")",
"return",
"rect"
] |
Draws an antialiased line on the surface.
|
[
"Draws",
"an",
"antialiased",
"line",
"on",
"the",
"surface",
"."
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/draw.py#L17-L52
|
ddorn/GUI
|
GUI/draw.py
|
circle
|
def circle(surf, xy, r, color=BLACK):
"""Draw an antialiased filled circle on the given surface"""
x, y = xy
x = round(x)
y = round(y)
r = round(r)
gfxdraw.filled_circle(surf, x, y, r, color)
gfxdraw.aacircle(surf, x, y, r, color)
r += 1
return pygame.Rect(x - r, y - r, 2 * r, 2 * r)
|
python
|
def circle(surf, xy, r, color=BLACK):
"""Draw an antialiased filled circle on the given surface"""
x, y = xy
x = round(x)
y = round(y)
r = round(r)
gfxdraw.filled_circle(surf, x, y, r, color)
gfxdraw.aacircle(surf, x, y, r, color)
r += 1
return pygame.Rect(x - r, y - r, 2 * r, 2 * r)
|
[
"def",
"circle",
"(",
"surf",
",",
"xy",
",",
"r",
",",
"color",
"=",
"BLACK",
")",
":",
"x",
",",
"y",
"=",
"xy",
"x",
"=",
"round",
"(",
"x",
")",
"y",
"=",
"round",
"(",
"y",
")",
"r",
"=",
"round",
"(",
"r",
")",
"gfxdraw",
".",
"filled_circle",
"(",
"surf",
",",
"x",
",",
"y",
",",
"r",
",",
"color",
")",
"gfxdraw",
".",
"aacircle",
"(",
"surf",
",",
"x",
",",
"y",
",",
"r",
",",
"color",
")",
"r",
"+=",
"1",
"return",
"pygame",
".",
"Rect",
"(",
"x",
"-",
"r",
",",
"y",
"-",
"r",
",",
"2",
"*",
"r",
",",
"2",
"*",
"r",
")"
] |
Draw an antialiased filled circle on the given surface
|
[
"Draw",
"an",
"antialiased",
"filled",
"circle",
"on",
"the",
"given",
"surface"
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/draw.py#L55-L68
|
ddorn/GUI
|
GUI/draw.py
|
ring
|
def ring(surf, xy, r, width, color):
"""Draws a ring"""
r2 = r - width
x0, y0 = xy
x = r2
y = 0
err = 0
# collect points of the inner circle
right = {}
while x >= y:
right[x] = y
right[y] = x
right[-x] = y
right[-y] = x
y += 1
if err <= 0:
err += 2 * y + 1
if err > 0:
x -= 1
err -= 2 * x + 1
def h_fill_the_circle(surf, color, x, y, right):
if -r2 <= y <= r2:
pygame.draw.line(surf, color, (x0 + right[y], y0 + y), (x0 + x, y0 + y))
pygame.draw.line(surf, color, (x0 - right[y], y0 + y), (x0 - x, y0 + y))
else:
pygame.draw.line(surf, color, (x0 - x, y0 + y), (x0 + x, y0 + y))
x = r
y = 0
err = 0
while x >= y:
h_fill_the_circle(surf, color, x, y, right)
h_fill_the_circle(surf, color, x, -y, right)
h_fill_the_circle(surf, color, y, x, right)
h_fill_the_circle(surf, color, y, -x, right)
y += 1
if err < 0:
err += 2 * y + 1
if err >= 0:
x -= 1
err -= 2 * x + 1
gfxdraw.aacircle(surf, x0, y0, r, color)
gfxdraw.aacircle(surf, x0, y0, r2, color)
|
python
|
def ring(surf, xy, r, width, color):
"""Draws a ring"""
r2 = r - width
x0, y0 = xy
x = r2
y = 0
err = 0
# collect points of the inner circle
right = {}
while x >= y:
right[x] = y
right[y] = x
right[-x] = y
right[-y] = x
y += 1
if err <= 0:
err += 2 * y + 1
if err > 0:
x -= 1
err -= 2 * x + 1
def h_fill_the_circle(surf, color, x, y, right):
if -r2 <= y <= r2:
pygame.draw.line(surf, color, (x0 + right[y], y0 + y), (x0 + x, y0 + y))
pygame.draw.line(surf, color, (x0 - right[y], y0 + y), (x0 - x, y0 + y))
else:
pygame.draw.line(surf, color, (x0 - x, y0 + y), (x0 + x, y0 + y))
x = r
y = 0
err = 0
while x >= y:
h_fill_the_circle(surf, color, x, y, right)
h_fill_the_circle(surf, color, x, -y, right)
h_fill_the_circle(surf, color, y, x, right)
h_fill_the_circle(surf, color, y, -x, right)
y += 1
if err < 0:
err += 2 * y + 1
if err >= 0:
x -= 1
err -= 2 * x + 1
gfxdraw.aacircle(surf, x0, y0, r, color)
gfxdraw.aacircle(surf, x0, y0, r2, color)
|
[
"def",
"ring",
"(",
"surf",
",",
"xy",
",",
"r",
",",
"width",
",",
"color",
")",
":",
"r2",
"=",
"r",
"-",
"width",
"x0",
",",
"y0",
"=",
"xy",
"x",
"=",
"r2",
"y",
"=",
"0",
"err",
"=",
"0",
"# collect points of the inner circle",
"right",
"=",
"{",
"}",
"while",
"x",
">=",
"y",
":",
"right",
"[",
"x",
"]",
"=",
"y",
"right",
"[",
"y",
"]",
"=",
"x",
"right",
"[",
"-",
"x",
"]",
"=",
"y",
"right",
"[",
"-",
"y",
"]",
"=",
"x",
"y",
"+=",
"1",
"if",
"err",
"<=",
"0",
":",
"err",
"+=",
"2",
"*",
"y",
"+",
"1",
"if",
"err",
">",
"0",
":",
"x",
"-=",
"1",
"err",
"-=",
"2",
"*",
"x",
"+",
"1",
"def",
"h_fill_the_circle",
"(",
"surf",
",",
"color",
",",
"x",
",",
"y",
",",
"right",
")",
":",
"if",
"-",
"r2",
"<=",
"y",
"<=",
"r2",
":",
"pygame",
".",
"draw",
".",
"line",
"(",
"surf",
",",
"color",
",",
"(",
"x0",
"+",
"right",
"[",
"y",
"]",
",",
"y0",
"+",
"y",
")",
",",
"(",
"x0",
"+",
"x",
",",
"y0",
"+",
"y",
")",
")",
"pygame",
".",
"draw",
".",
"line",
"(",
"surf",
",",
"color",
",",
"(",
"x0",
"-",
"right",
"[",
"y",
"]",
",",
"y0",
"+",
"y",
")",
",",
"(",
"x0",
"-",
"x",
",",
"y0",
"+",
"y",
")",
")",
"else",
":",
"pygame",
".",
"draw",
".",
"line",
"(",
"surf",
",",
"color",
",",
"(",
"x0",
"-",
"x",
",",
"y0",
"+",
"y",
")",
",",
"(",
"x0",
"+",
"x",
",",
"y0",
"+",
"y",
")",
")",
"x",
"=",
"r",
"y",
"=",
"0",
"err",
"=",
"0",
"while",
"x",
">=",
"y",
":",
"h_fill_the_circle",
"(",
"surf",
",",
"color",
",",
"x",
",",
"y",
",",
"right",
")",
"h_fill_the_circle",
"(",
"surf",
",",
"color",
",",
"x",
",",
"-",
"y",
",",
"right",
")",
"h_fill_the_circle",
"(",
"surf",
",",
"color",
",",
"y",
",",
"x",
",",
"right",
")",
"h_fill_the_circle",
"(",
"surf",
",",
"color",
",",
"y",
",",
"-",
"x",
",",
"right",
")",
"y",
"+=",
"1",
"if",
"err",
"<",
"0",
":",
"err",
"+=",
"2",
"*",
"y",
"+",
"1",
"if",
"err",
">=",
"0",
":",
"x",
"-=",
"1",
"err",
"-=",
"2",
"*",
"x",
"+",
"1",
"gfxdraw",
".",
"aacircle",
"(",
"surf",
",",
"x0",
",",
"y0",
",",
"r",
",",
"color",
")",
"gfxdraw",
".",
"aacircle",
"(",
"surf",
",",
"x0",
",",
"y0",
",",
"r2",
",",
"color",
")"
] |
Draws a ring
|
[
"Draws",
"a",
"ring"
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/draw.py#L71-L122
|
ddorn/GUI
|
GUI/draw.py
|
roundrect
|
def roundrect(surface, rect, color, rounding=5, unit=PIXEL):
"""
Draw an antialiased round rectangle on the surface.
surface : destination
rect : rectangle
color : rgb or rgba
radius : 0 <= radius <= 1
:source: http://pygame.org/project-AAfilledRoundedRect-2349-.html
"""
if unit == PERCENT:
rounding = int(min(rect.size) / 2 * rounding / 100)
rect = pygame.Rect(rect)
color = pygame.Color(*color)
alpha = color.a
color.a = 0
pos = rect.topleft
rect.topleft = 0, 0
rectangle = pygame.Surface(rect.size, SRCALPHA)
circle = pygame.Surface([min(rect.size) * 3] * 2, SRCALPHA)
pygame.draw.ellipse(circle, (0, 0, 0), circle.get_rect(), 0)
circle = pygame.transform.smoothscale(circle, (rounding, rounding))
rounding = rectangle.blit(circle, (0, 0))
rounding.bottomright = rect.bottomright
rectangle.blit(circle, rounding)
rounding.topright = rect.topright
rectangle.blit(circle, rounding)
rounding.bottomleft = rect.bottomleft
rectangle.blit(circle, rounding)
rectangle.fill((0, 0, 0), rect.inflate(-rounding.w, 0))
rectangle.fill((0, 0, 0), rect.inflate(0, -rounding.h))
rectangle.fill(color, special_flags=BLEND_RGBA_MAX)
rectangle.fill((255, 255, 255, alpha), special_flags=BLEND_RGBA_MIN)
return surface.blit(rectangle, pos)
|
python
|
def roundrect(surface, rect, color, rounding=5, unit=PIXEL):
"""
Draw an antialiased round rectangle on the surface.
surface : destination
rect : rectangle
color : rgb or rgba
radius : 0 <= radius <= 1
:source: http://pygame.org/project-AAfilledRoundedRect-2349-.html
"""
if unit == PERCENT:
rounding = int(min(rect.size) / 2 * rounding / 100)
rect = pygame.Rect(rect)
color = pygame.Color(*color)
alpha = color.a
color.a = 0
pos = rect.topleft
rect.topleft = 0, 0
rectangle = pygame.Surface(rect.size, SRCALPHA)
circle = pygame.Surface([min(rect.size) * 3] * 2, SRCALPHA)
pygame.draw.ellipse(circle, (0, 0, 0), circle.get_rect(), 0)
circle = pygame.transform.smoothscale(circle, (rounding, rounding))
rounding = rectangle.blit(circle, (0, 0))
rounding.bottomright = rect.bottomright
rectangle.blit(circle, rounding)
rounding.topright = rect.topright
rectangle.blit(circle, rounding)
rounding.bottomleft = rect.bottomleft
rectangle.blit(circle, rounding)
rectangle.fill((0, 0, 0), rect.inflate(-rounding.w, 0))
rectangle.fill((0, 0, 0), rect.inflate(0, -rounding.h))
rectangle.fill(color, special_flags=BLEND_RGBA_MAX)
rectangle.fill((255, 255, 255, alpha), special_flags=BLEND_RGBA_MIN)
return surface.blit(rectangle, pos)
|
[
"def",
"roundrect",
"(",
"surface",
",",
"rect",
",",
"color",
",",
"rounding",
"=",
"5",
",",
"unit",
"=",
"PIXEL",
")",
":",
"if",
"unit",
"==",
"PERCENT",
":",
"rounding",
"=",
"int",
"(",
"min",
"(",
"rect",
".",
"size",
")",
"/",
"2",
"*",
"rounding",
"/",
"100",
")",
"rect",
"=",
"pygame",
".",
"Rect",
"(",
"rect",
")",
"color",
"=",
"pygame",
".",
"Color",
"(",
"*",
"color",
")",
"alpha",
"=",
"color",
".",
"a",
"color",
".",
"a",
"=",
"0",
"pos",
"=",
"rect",
".",
"topleft",
"rect",
".",
"topleft",
"=",
"0",
",",
"0",
"rectangle",
"=",
"pygame",
".",
"Surface",
"(",
"rect",
".",
"size",
",",
"SRCALPHA",
")",
"circle",
"=",
"pygame",
".",
"Surface",
"(",
"[",
"min",
"(",
"rect",
".",
"size",
")",
"*",
"3",
"]",
"*",
"2",
",",
"SRCALPHA",
")",
"pygame",
".",
"draw",
".",
"ellipse",
"(",
"circle",
",",
"(",
"0",
",",
"0",
",",
"0",
")",
",",
"circle",
".",
"get_rect",
"(",
")",
",",
"0",
")",
"circle",
"=",
"pygame",
".",
"transform",
".",
"smoothscale",
"(",
"circle",
",",
"(",
"rounding",
",",
"rounding",
")",
")",
"rounding",
"=",
"rectangle",
".",
"blit",
"(",
"circle",
",",
"(",
"0",
",",
"0",
")",
")",
"rounding",
".",
"bottomright",
"=",
"rect",
".",
"bottomright",
"rectangle",
".",
"blit",
"(",
"circle",
",",
"rounding",
")",
"rounding",
".",
"topright",
"=",
"rect",
".",
"topright",
"rectangle",
".",
"blit",
"(",
"circle",
",",
"rounding",
")",
"rounding",
".",
"bottomleft",
"=",
"rect",
".",
"bottomleft",
"rectangle",
".",
"blit",
"(",
"circle",
",",
"rounding",
")",
"rectangle",
".",
"fill",
"(",
"(",
"0",
",",
"0",
",",
"0",
")",
",",
"rect",
".",
"inflate",
"(",
"-",
"rounding",
".",
"w",
",",
"0",
")",
")",
"rectangle",
".",
"fill",
"(",
"(",
"0",
",",
"0",
",",
"0",
")",
",",
"rect",
".",
"inflate",
"(",
"0",
",",
"-",
"rounding",
".",
"h",
")",
")",
"rectangle",
".",
"fill",
"(",
"color",
",",
"special_flags",
"=",
"BLEND_RGBA_MAX",
")",
"rectangle",
".",
"fill",
"(",
"(",
"255",
",",
"255",
",",
"255",
",",
"alpha",
")",
",",
"special_flags",
"=",
"BLEND_RGBA_MIN",
")",
"return",
"surface",
".",
"blit",
"(",
"rectangle",
",",
"pos",
")"
] |
Draw an antialiased round rectangle on the surface.
surface : destination
rect : rectangle
color : rgb or rgba
radius : 0 <= radius <= 1
:source: http://pygame.org/project-AAfilledRoundedRect-2349-.html
|
[
"Draw",
"an",
"antialiased",
"round",
"rectangle",
"on",
"the",
"surface",
"."
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/draw.py#L125-L165
|
ddorn/GUI
|
GUI/draw.py
|
polygon
|
def polygon(surf, points, color):
"""Draw an antialiased filled polygon on a surface"""
gfxdraw.aapolygon(surf, points, color)
gfxdraw.filled_polygon(surf, points, color)
x = min([x for (x, y) in points])
y = min([y for (x, y) in points])
xm = max([x for (x, y) in points])
ym = max([y for (x, y) in points])
return pygame.Rect(x, y, xm - x, ym - y)
|
python
|
def polygon(surf, points, color):
"""Draw an antialiased filled polygon on a surface"""
gfxdraw.aapolygon(surf, points, color)
gfxdraw.filled_polygon(surf, points, color)
x = min([x for (x, y) in points])
y = min([y for (x, y) in points])
xm = max([x for (x, y) in points])
ym = max([y for (x, y) in points])
return pygame.Rect(x, y, xm - x, ym - y)
|
[
"def",
"polygon",
"(",
"surf",
",",
"points",
",",
"color",
")",
":",
"gfxdraw",
".",
"aapolygon",
"(",
"surf",
",",
"points",
",",
"color",
")",
"gfxdraw",
".",
"filled_polygon",
"(",
"surf",
",",
"points",
",",
"color",
")",
"x",
"=",
"min",
"(",
"[",
"x",
"for",
"(",
"x",
",",
"y",
")",
"in",
"points",
"]",
")",
"y",
"=",
"min",
"(",
"[",
"y",
"for",
"(",
"x",
",",
"y",
")",
"in",
"points",
"]",
")",
"xm",
"=",
"max",
"(",
"[",
"x",
"for",
"(",
"x",
",",
"y",
")",
"in",
"points",
"]",
")",
"ym",
"=",
"max",
"(",
"[",
"y",
"for",
"(",
"x",
",",
"y",
")",
"in",
"points",
"]",
")",
"return",
"pygame",
".",
"Rect",
"(",
"x",
",",
"y",
",",
"xm",
"-",
"x",
",",
"ym",
"-",
"y",
")"
] |
Draw an antialiased filled polygon on a surface
|
[
"Draw",
"an",
"antialiased",
"filled",
"polygon",
"on",
"a",
"surface"
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/draw.py#L168-L179
|
ddorn/GUI
|
GUI/buttons.py
|
BaseButton.click
|
def click(self, force_no_call=False, milis=None):
"""
Call when the button is pressed. This start the callback function in a thread
If :milis is given, will release the button after :milis miliseconds
"""
if self.clicked:
return False
if not force_no_call and self.flags & self.CALL_ON_PRESS:
if self.flags & self.THREADED_CALL:
start_new_thread(self.func, ())
else:
self.func()
super().click()
if milis is not None:
start_new_thread(self.release, (), {'milis': milis})
|
python
|
def click(self, force_no_call=False, milis=None):
"""
Call when the button is pressed. This start the callback function in a thread
If :milis is given, will release the button after :milis miliseconds
"""
if self.clicked:
return False
if not force_no_call and self.flags & self.CALL_ON_PRESS:
if self.flags & self.THREADED_CALL:
start_new_thread(self.func, ())
else:
self.func()
super().click()
if milis is not None:
start_new_thread(self.release, (), {'milis': milis})
|
[
"def",
"click",
"(",
"self",
",",
"force_no_call",
"=",
"False",
",",
"milis",
"=",
"None",
")",
":",
"if",
"self",
".",
"clicked",
":",
"return",
"False",
"if",
"not",
"force_no_call",
"and",
"self",
".",
"flags",
"&",
"self",
".",
"CALL_ON_PRESS",
":",
"if",
"self",
".",
"flags",
"&",
"self",
".",
"THREADED_CALL",
":",
"start_new_thread",
"(",
"self",
".",
"func",
",",
"(",
")",
")",
"else",
":",
"self",
".",
"func",
"(",
")",
"super",
"(",
")",
".",
"click",
"(",
")",
"if",
"milis",
"is",
"not",
"None",
":",
"start_new_thread",
"(",
"self",
".",
"release",
",",
"(",
")",
",",
"{",
"'milis'",
":",
"milis",
"}",
")"
] |
Call when the button is pressed. This start the callback function in a thread
If :milis is given, will release the button after :milis miliseconds
|
[
"Call",
"when",
"the",
"button",
"is",
"pressed",
".",
"This",
"start",
"the",
"callback",
"function",
"in",
"a",
"thread",
"If",
":",
"milis",
"is",
"given",
"will",
"release",
"the",
"button",
"after",
":",
"milis",
"miliseconds"
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/buttons.py#L42-L60
|
ddorn/GUI
|
GUI/buttons.py
|
Button._get_color
|
def _get_color(self):
"""Return the color of the button, depending on its state"""
if self.clicked and self.hovered: # the mouse is over the button
color = mix(self.color, BLACK, 0.8)
elif self.hovered and not self.flags & self.NO_HOVER:
color = mix(self.color, BLACK, 0.93)
else:
color = self.color
self.text.bg_color = color
return color
|
python
|
def _get_color(self):
"""Return the color of the button, depending on its state"""
if self.clicked and self.hovered: # the mouse is over the button
color = mix(self.color, BLACK, 0.8)
elif self.hovered and not self.flags & self.NO_HOVER:
color = mix(self.color, BLACK, 0.93)
else:
color = self.color
self.text.bg_color = color
return color
|
[
"def",
"_get_color",
"(",
"self",
")",
":",
"if",
"self",
".",
"clicked",
"and",
"self",
".",
"hovered",
":",
"# the mouse is over the button",
"color",
"=",
"mix",
"(",
"self",
".",
"color",
",",
"BLACK",
",",
"0.8",
")",
"elif",
"self",
".",
"hovered",
"and",
"not",
"self",
".",
"flags",
"&",
"self",
".",
"NO_HOVER",
":",
"color",
"=",
"mix",
"(",
"self",
".",
"color",
",",
"BLACK",
",",
"0.93",
")",
"else",
":",
"color",
"=",
"self",
".",
"color",
"self",
".",
"text",
".",
"bg_color",
"=",
"color",
"return",
"color"
] |
Return the color of the button, depending on its state
|
[
"Return",
"the",
"color",
"of",
"the",
"button",
"depending",
"on",
"its",
"state"
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/buttons.py#L118-L130
|
ddorn/GUI
|
GUI/buttons.py
|
Button._front_delta
|
def _front_delta(self):
"""Return the offset of the colored part."""
if self.flags & self.NO_MOVE:
return Separator(0, 0)
if self.clicked and self.hovered: # the mouse is over the button
delta = 2
elif self.hovered and not self.flags & self.NO_HOVER:
delta = 0
else:
delta = 0
return Separator(delta, delta)
|
python
|
def _front_delta(self):
"""Return the offset of the colored part."""
if self.flags & self.NO_MOVE:
return Separator(0, 0)
if self.clicked and self.hovered: # the mouse is over the button
delta = 2
elif self.hovered and not self.flags & self.NO_HOVER:
delta = 0
else:
delta = 0
return Separator(delta, delta)
|
[
"def",
"_front_delta",
"(",
"self",
")",
":",
"if",
"self",
".",
"flags",
"&",
"self",
".",
"NO_MOVE",
":",
"return",
"Separator",
"(",
"0",
",",
"0",
")",
"if",
"self",
".",
"clicked",
"and",
"self",
".",
"hovered",
":",
"# the mouse is over the button",
"delta",
"=",
"2",
"elif",
"self",
".",
"hovered",
"and",
"not",
"self",
".",
"flags",
"&",
"self",
".",
"NO_HOVER",
":",
"delta",
"=",
"0",
"else",
":",
"delta",
"=",
"0",
"return",
"Separator",
"(",
"delta",
",",
"delta",
")"
] |
Return the offset of the colored part.
|
[
"Return",
"the",
"offset",
"of",
"the",
"colored",
"part",
"."
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/buttons.py#L133-L147
|
ddorn/GUI
|
GUI/buttons.py
|
Button.update
|
def update(self, event_or_list):
"""Update the button with the events."""
for e in super().update(event_or_list):
if e.type == MOUSEBUTTONDOWN:
if e.pos in self:
self.click()
else:
self.release(force_no_call=True)
elif e.type == MOUSEBUTTONUP:
self.release(force_no_call=e.pos not in self)
elif e.type == MOUSEMOTION:
if e.pos in self:
self.hovered = True
else:
self.hovered = False
|
python
|
def update(self, event_or_list):
"""Update the button with the events."""
for e in super().update(event_or_list):
if e.type == MOUSEBUTTONDOWN:
if e.pos in self:
self.click()
else:
self.release(force_no_call=True)
elif e.type == MOUSEBUTTONUP:
self.release(force_no_call=e.pos not in self)
elif e.type == MOUSEMOTION:
if e.pos in self:
self.hovered = True
else:
self.hovered = False
|
[
"def",
"update",
"(",
"self",
",",
"event_or_list",
")",
":",
"for",
"e",
"in",
"super",
"(",
")",
".",
"update",
"(",
"event_or_list",
")",
":",
"if",
"e",
".",
"type",
"==",
"MOUSEBUTTONDOWN",
":",
"if",
"e",
".",
"pos",
"in",
"self",
":",
"self",
".",
"click",
"(",
")",
"else",
":",
"self",
".",
"release",
"(",
"force_no_call",
"=",
"True",
")",
"elif",
"e",
".",
"type",
"==",
"MOUSEBUTTONUP",
":",
"self",
".",
"release",
"(",
"force_no_call",
"=",
"e",
".",
"pos",
"not",
"in",
"self",
")",
"elif",
"e",
".",
"type",
"==",
"MOUSEMOTION",
":",
"if",
"e",
".",
"pos",
"in",
"self",
":",
"self",
".",
"hovered",
"=",
"True",
"else",
":",
"self",
".",
"hovered",
"=",
"False"
] |
Update the button with the events.
|
[
"Update",
"the",
"button",
"with",
"the",
"events",
"."
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/buttons.py#L166-L183
|
ddorn/GUI
|
GUI/buttons.py
|
Button.render
|
def render(self, surf):
"""Render the button on a surface."""
pos, size = self.topleft, self.size
if not self.flags & self.NO_SHADOW:
if self.flags & self.NO_ROUNDING:
pygame.draw.rect(surf, LIGHT_GREY, (pos + self._bg_delta, size))
else:
roundrect(surf, (pos + self._bg_delta, size), LIGHT_GREY + (100,), 5)
if self.flags & self.NO_ROUNDING:
pygame.draw.rect(surf, self._get_color(), (pos + self._front_delta, size))
else:
roundrect(surf, (pos + self._front_delta, size), self._get_color(), 5)
self.text.center = self.center + self._front_delta
self.text.render(surf)
|
python
|
def render(self, surf):
"""Render the button on a surface."""
pos, size = self.topleft, self.size
if not self.flags & self.NO_SHADOW:
if self.flags & self.NO_ROUNDING:
pygame.draw.rect(surf, LIGHT_GREY, (pos + self._bg_delta, size))
else:
roundrect(surf, (pos + self._bg_delta, size), LIGHT_GREY + (100,), 5)
if self.flags & self.NO_ROUNDING:
pygame.draw.rect(surf, self._get_color(), (pos + self._front_delta, size))
else:
roundrect(surf, (pos + self._front_delta, size), self._get_color(), 5)
self.text.center = self.center + self._front_delta
self.text.render(surf)
|
[
"def",
"render",
"(",
"self",
",",
"surf",
")",
":",
"pos",
",",
"size",
"=",
"self",
".",
"topleft",
",",
"self",
".",
"size",
"if",
"not",
"self",
".",
"flags",
"&",
"self",
".",
"NO_SHADOW",
":",
"if",
"self",
".",
"flags",
"&",
"self",
".",
"NO_ROUNDING",
":",
"pygame",
".",
"draw",
".",
"rect",
"(",
"surf",
",",
"LIGHT_GREY",
",",
"(",
"pos",
"+",
"self",
".",
"_bg_delta",
",",
"size",
")",
")",
"else",
":",
"roundrect",
"(",
"surf",
",",
"(",
"pos",
"+",
"self",
".",
"_bg_delta",
",",
"size",
")",
",",
"LIGHT_GREY",
"+",
"(",
"100",
",",
")",
",",
"5",
")",
"if",
"self",
".",
"flags",
"&",
"self",
".",
"NO_ROUNDING",
":",
"pygame",
".",
"draw",
".",
"rect",
"(",
"surf",
",",
"self",
".",
"_get_color",
"(",
")",
",",
"(",
"pos",
"+",
"self",
".",
"_front_delta",
",",
"size",
")",
")",
"else",
":",
"roundrect",
"(",
"surf",
",",
"(",
"pos",
"+",
"self",
".",
"_front_delta",
",",
"size",
")",
",",
"self",
".",
"_get_color",
"(",
")",
",",
"5",
")",
"self",
".",
"text",
".",
"center",
"=",
"self",
".",
"center",
"+",
"self",
".",
"_front_delta",
"self",
".",
"text",
".",
"render",
"(",
"surf",
")"
] |
Render the button on a surface.
|
[
"Render",
"the",
"button",
"on",
"a",
"surface",
"."
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/buttons.py#L185-L201
|
ddorn/GUI
|
GUI/buttons.py
|
RoundButton.render
|
def render(self, surf):
"""Draw the button on the surface."""
if not self.flags & self.NO_SHADOW:
circle(surf, self.center + self._bg_delta, self.width / 2, LIGHT_GREY)
circle(surf, self.center + self._front_delta, self.width / 2, self._get_color())
self.text.center = self.center + self._front_delta
self.text.render(surf)
|
python
|
def render(self, surf):
"""Draw the button on the surface."""
if not self.flags & self.NO_SHADOW:
circle(surf, self.center + self._bg_delta, self.width / 2, LIGHT_GREY)
circle(surf, self.center + self._front_delta, self.width / 2, self._get_color())
self.text.center = self.center + self._front_delta
self.text.render(surf)
|
[
"def",
"render",
"(",
"self",
",",
"surf",
")",
":",
"if",
"not",
"self",
".",
"flags",
"&",
"self",
".",
"NO_SHADOW",
":",
"circle",
"(",
"surf",
",",
"self",
".",
"center",
"+",
"self",
".",
"_bg_delta",
",",
"self",
".",
"width",
"/",
"2",
",",
"LIGHT_GREY",
")",
"circle",
"(",
"surf",
",",
"self",
".",
"center",
"+",
"self",
".",
"_front_delta",
",",
"self",
".",
"width",
"/",
"2",
",",
"self",
".",
"_get_color",
"(",
")",
")",
"self",
".",
"text",
".",
"center",
"=",
"self",
".",
"center",
"+",
"self",
".",
"_front_delta",
"self",
".",
"text",
".",
"render",
"(",
"surf",
")"
] |
Draw the button on the surface.
|
[
"Draw",
"the",
"button",
"on",
"the",
"surface",
"."
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/buttons.py#L211-L218
|
ddorn/GUI
|
GUI/buttons.py
|
IconButton.get_darker_image
|
def get_darker_image(self):
"""Returns an icon 80% more dark"""
icon_pressed = self.icon.copy()
for x in range(self.w):
for y in range(self.h):
r, g, b, *_ = tuple(self.icon.get_at((x, y)))
const = 0.8
r = int(const * r)
g = int(const * g)
b = int(const * b)
icon_pressed.set_at((x, y), (r, g, b))
return icon_pressed
|
python
|
def get_darker_image(self):
"""Returns an icon 80% more dark"""
icon_pressed = self.icon.copy()
for x in range(self.w):
for y in range(self.h):
r, g, b, *_ = tuple(self.icon.get_at((x, y)))
const = 0.8
r = int(const * r)
g = int(const * g)
b = int(const * b)
icon_pressed.set_at((x, y), (r, g, b))
return icon_pressed
|
[
"def",
"get_darker_image",
"(",
"self",
")",
":",
"icon_pressed",
"=",
"self",
".",
"icon",
".",
"copy",
"(",
")",
"for",
"x",
"in",
"range",
"(",
"self",
".",
"w",
")",
":",
"for",
"y",
"in",
"range",
"(",
"self",
".",
"h",
")",
":",
"r",
",",
"g",
",",
"b",
",",
"",
"*",
"_",
"=",
"tuple",
"(",
"self",
".",
"icon",
".",
"get_at",
"(",
"(",
"x",
",",
"y",
")",
")",
")",
"const",
"=",
"0.8",
"r",
"=",
"int",
"(",
"const",
"*",
"r",
")",
"g",
"=",
"int",
"(",
"const",
"*",
"g",
")",
"b",
"=",
"int",
"(",
"const",
"*",
"b",
")",
"icon_pressed",
".",
"set_at",
"(",
"(",
"x",
",",
"y",
")",
",",
"(",
"r",
",",
"g",
",",
"b",
")",
")",
"return",
"icon_pressed"
] |
Returns an icon 80% more dark
|
[
"Returns",
"an",
"icon",
"80%",
"more",
"dark"
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/buttons.py#L244-L257
|
ddorn/GUI
|
GUI/buttons.py
|
IconButton.render
|
def render(self, surf):
"""Render the button"""
if self.clicked:
icon = self.icon_pressed
else:
icon = self.icon
surf.blit(icon, self)
|
python
|
def render(self, surf):
"""Render the button"""
if self.clicked:
icon = self.icon_pressed
else:
icon = self.icon
surf.blit(icon, self)
|
[
"def",
"render",
"(",
"self",
",",
"surf",
")",
":",
"if",
"self",
".",
"clicked",
":",
"icon",
"=",
"self",
".",
"icon_pressed",
"else",
":",
"icon",
"=",
"self",
".",
"icon",
"surf",
".",
"blit",
"(",
"icon",
",",
"self",
")"
] |
Render the button
|
[
"Render",
"the",
"button"
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/buttons.py#L259-L267
|
ddorn/GUI
|
GUI/buttons.py
|
SlideBar.set
|
def set(self, value):
"""Set the value of the bar. If the value is out of bound, sets it to an extremum"""
value = min(self.max, max(self.min, value))
self._value = value
start_new_thread(self.func, (self.get(),))
|
python
|
def set(self, value):
"""Set the value of the bar. If the value is out of bound, sets it to an extremum"""
value = min(self.max, max(self.min, value))
self._value = value
start_new_thread(self.func, (self.get(),))
|
[
"def",
"set",
"(",
"self",
",",
"value",
")",
":",
"value",
"=",
"min",
"(",
"self",
".",
"max",
",",
"max",
"(",
"self",
".",
"min",
",",
"value",
")",
")",
"self",
".",
"_value",
"=",
"value",
"start_new_thread",
"(",
"self",
".",
"func",
",",
"(",
"self",
".",
"get",
"(",
")",
",",
")",
")"
] |
Set the value of the bar. If the value is out of bound, sets it to an extremum
|
[
"Set",
"the",
"value",
"of",
"the",
"bar",
".",
"If",
"the",
"value",
"is",
"out",
"of",
"bound",
"sets",
"it",
"to",
"an",
"extremum"
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/buttons.py#L327-L331
|
ddorn/GUI
|
GUI/buttons.py
|
SlideBar._start
|
def _start(self):
"""Starts checking if the SB is shifted"""
# TODO : make an update method instead
last_call = 42
while self._focus:
sleep(1 / 100)
mouse = pygame.mouse.get_pos()
last_value = self.get()
self.value_px = mouse[0]
# we do not need to do anything when it the same value
if self.get() == last_value:
continue
if last_call + self.interval / 1000 < time():
last_call = time()
self.func(self.get())
|
python
|
def _start(self):
"""Starts checking if the SB is shifted"""
# TODO : make an update method instead
last_call = 42
while self._focus:
sleep(1 / 100)
mouse = pygame.mouse.get_pos()
last_value = self.get()
self.value_px = mouse[0]
# we do not need to do anything when it the same value
if self.get() == last_value:
continue
if last_call + self.interval / 1000 < time():
last_call = time()
self.func(self.get())
|
[
"def",
"_start",
"(",
"self",
")",
":",
"# TODO : make an update method instead",
"last_call",
"=",
"42",
"while",
"self",
".",
"_focus",
":",
"sleep",
"(",
"1",
"/",
"100",
")",
"mouse",
"=",
"pygame",
".",
"mouse",
".",
"get_pos",
"(",
")",
"last_value",
"=",
"self",
".",
"get",
"(",
")",
"self",
".",
"value_px",
"=",
"mouse",
"[",
"0",
"]",
"# we do not need to do anything when it the same value",
"if",
"self",
".",
"get",
"(",
")",
"==",
"last_value",
":",
"continue",
"if",
"last_call",
"+",
"self",
".",
"interval",
"/",
"1000",
"<",
"time",
"(",
")",
":",
"last_call",
"=",
"time",
"(",
")",
"self",
".",
"func",
"(",
"self",
".",
"get",
"(",
")",
")"
] |
Starts checking if the SB is shifted
|
[
"Starts",
"checking",
"if",
"the",
"SB",
"is",
"shifted"
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/buttons.py#L333-L352
|
ddorn/GUI
|
GUI/buttons.py
|
SlideBar.value_px
|
def value_px(self):
"""The position in pixels of the cursor"""
step = self.w / (self.max - self.min)
return self.x + step * (self.get() - self.min)
|
python
|
def value_px(self):
"""The position in pixels of the cursor"""
step = self.w / (self.max - self.min)
return self.x + step * (self.get() - self.min)
|
[
"def",
"value_px",
"(",
"self",
")",
":",
"step",
"=",
"self",
".",
"w",
"/",
"(",
"self",
".",
"max",
"-",
"self",
".",
"min",
")",
"return",
"self",
".",
"x",
"+",
"step",
"*",
"(",
"self",
".",
"get",
"(",
")",
"-",
"self",
".",
"min",
")"
] |
The position in pixels of the cursor
|
[
"The",
"position",
"in",
"pixels",
"of",
"the",
"cursor"
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/buttons.py#L361-L364
|
ddorn/GUI
|
GUI/buttons.py
|
SlideBar.render
|
def render(self, display):
"""Renders the bar on the display"""
# the bar
bar_rect = pygame.Rect(0, 0, self.width, self.height // 3)
bar_rect.center = self.center
display.fill(self.bg_color, bar_rect)
# the cursor
circle(display, (self.value_px, self.centery), self.height // 2, self.color)
# the value
if self.show_val:
self.text_val.render(display)
|
python
|
def render(self, display):
"""Renders the bar on the display"""
# the bar
bar_rect = pygame.Rect(0, 0, self.width, self.height // 3)
bar_rect.center = self.center
display.fill(self.bg_color, bar_rect)
# the cursor
circle(display, (self.value_px, self.centery), self.height // 2, self.color)
# the value
if self.show_val:
self.text_val.render(display)
|
[
"def",
"render",
"(",
"self",
",",
"display",
")",
":",
"# the bar",
"bar_rect",
"=",
"pygame",
".",
"Rect",
"(",
"0",
",",
"0",
",",
"self",
".",
"width",
",",
"self",
".",
"height",
"//",
"3",
")",
"bar_rect",
".",
"center",
"=",
"self",
".",
"center",
"display",
".",
"fill",
"(",
"self",
".",
"bg_color",
",",
"bar_rect",
")",
"# the cursor",
"circle",
"(",
"display",
",",
"(",
"self",
".",
"value_px",
",",
"self",
".",
"centery",
")",
",",
"self",
".",
"height",
"//",
"2",
",",
"self",
".",
"color",
")",
"# the value",
"if",
"self",
".",
"show_val",
":",
"self",
".",
"text_val",
".",
"render",
"(",
"display",
")"
] |
Renders the bar on the display
|
[
"Renders",
"the",
"bar",
"on",
"the",
"display"
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/buttons.py#L375-L388
|
ddorn/GUI
|
GUI/base.py
|
BaseWidget.__update
|
def __update(self):
"""
This is called each time an attribute is asked, to be sure every params are updated, beceause of callbacks.
"""
# I can not set the size attr because it is my property, so I set the width and height separately
width, height = self.size
super(BaseWidget, self).__setattr__("width", width)
super(BaseWidget, self).__setattr__("height", height)
super(BaseWidget, self).__setattr__(self.anchor, self.pos)
|
python
|
def __update(self):
"""
This is called each time an attribute is asked, to be sure every params are updated, beceause of callbacks.
"""
# I can not set the size attr because it is my property, so I set the width and height separately
width, height = self.size
super(BaseWidget, self).__setattr__("width", width)
super(BaseWidget, self).__setattr__("height", height)
super(BaseWidget, self).__setattr__(self.anchor, self.pos)
|
[
"def",
"__update",
"(",
"self",
")",
":",
"# I can not set the size attr because it is my property, so I set the width and height separately",
"width",
",",
"height",
"=",
"self",
".",
"size",
"super",
"(",
"BaseWidget",
",",
"self",
")",
".",
"__setattr__",
"(",
"\"width\"",
",",
"width",
")",
"super",
"(",
"BaseWidget",
",",
"self",
")",
".",
"__setattr__",
"(",
"\"height\"",
",",
"height",
")",
"super",
"(",
"BaseWidget",
",",
"self",
")",
".",
"__setattr__",
"(",
"self",
".",
"anchor",
",",
"self",
".",
"pos",
")"
] |
This is called each time an attribute is asked, to be sure every params are updated, beceause of callbacks.
|
[
"This",
"is",
"called",
"each",
"time",
"an",
"attribute",
"is",
"asked",
"to",
"be",
"sure",
"every",
"params",
"are",
"updated",
"beceause",
"of",
"callbacks",
"."
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/base.py#L83-L92
|
erikrose/peep
|
peep.py
|
activate
|
def activate(specifier):
"""Make a compatible version of pip importable. Raise a RuntimeError if we
couldn't."""
try:
for distro in require(specifier):
distro.activate()
except (VersionConflict, DistributionNotFound):
raise RuntimeError('The installed version of pip is too old; peep '
'requires ' + specifier)
|
python
|
def activate(specifier):
"""Make a compatible version of pip importable. Raise a RuntimeError if we
couldn't."""
try:
for distro in require(specifier):
distro.activate()
except (VersionConflict, DistributionNotFound):
raise RuntimeError('The installed version of pip is too old; peep '
'requires ' + specifier)
|
[
"def",
"activate",
"(",
"specifier",
")",
":",
"try",
":",
"for",
"distro",
"in",
"require",
"(",
"specifier",
")",
":",
"distro",
".",
"activate",
"(",
")",
"except",
"(",
"VersionConflict",
",",
"DistributionNotFound",
")",
":",
"raise",
"RuntimeError",
"(",
"'The installed version of pip is too old; peep '",
"'requires '",
"+",
"specifier",
")"
] |
Make a compatible version of pip importable. Raise a RuntimeError if we
couldn't.
|
[
"Make",
"a",
"compatible",
"version",
"of",
"pip",
"importable",
".",
"Raise",
"a",
"RuntimeError",
"if",
"we",
"couldn",
"t",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L65-L73
|
erikrose/peep
|
peep.py
|
path_and_line
|
def path_and_line(req):
"""Return the path and line number of the file from which an
InstallRequirement came.
"""
path, line = (re.match(r'-r (.*) \(line (\d+)\)$',
req.comes_from).groups())
return path, int(line)
|
python
|
def path_and_line(req):
"""Return the path and line number of the file from which an
InstallRequirement came.
"""
path, line = (re.match(r'-r (.*) \(line (\d+)\)$',
req.comes_from).groups())
return path, int(line)
|
[
"def",
"path_and_line",
"(",
"req",
")",
":",
"path",
",",
"line",
"=",
"(",
"re",
".",
"match",
"(",
"r'-r (.*) \\(line (\\d+)\\)$'",
",",
"req",
".",
"comes_from",
")",
".",
"groups",
"(",
")",
")",
"return",
"path",
",",
"int",
"(",
"line",
")"
] |
Return the path and line number of the file from which an
InstallRequirement came.
|
[
"Return",
"the",
"path",
"and",
"line",
"number",
"of",
"the",
"file",
"from",
"which",
"an",
"InstallRequirement",
"came",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L164-L171
|
erikrose/peep
|
peep.py
|
hashes_above
|
def hashes_above(path, line_number):
"""Yield hashes from contiguous comment lines before line ``line_number``.
"""
def hash_lists(path):
"""Yield lists of hashes appearing between non-comment lines.
The lists will be in order of appearance and, for each non-empty
list, their place in the results will coincide with that of the
line number of the corresponding result from `parse_requirements`
(which changed in pip 7.0 to not count comments).
"""
hashes = []
with open(path) as file:
for lineno, line in enumerate(file, 1):
match = HASH_COMMENT_RE.match(line)
if match: # Accumulate this hash.
hashes.append(match.groupdict()['hash'])
if not IGNORED_LINE_RE.match(line):
yield hashes # Report hashes seen so far.
hashes = []
elif PIP_COUNTS_COMMENTS:
# Comment: count as normal req but have no hashes.
yield []
return next(islice(hash_lists(path), line_number - 1, None))
|
python
|
def hashes_above(path, line_number):
"""Yield hashes from contiguous comment lines before line ``line_number``.
"""
def hash_lists(path):
"""Yield lists of hashes appearing between non-comment lines.
The lists will be in order of appearance and, for each non-empty
list, their place in the results will coincide with that of the
line number of the corresponding result from `parse_requirements`
(which changed in pip 7.0 to not count comments).
"""
hashes = []
with open(path) as file:
for lineno, line in enumerate(file, 1):
match = HASH_COMMENT_RE.match(line)
if match: # Accumulate this hash.
hashes.append(match.groupdict()['hash'])
if not IGNORED_LINE_RE.match(line):
yield hashes # Report hashes seen so far.
hashes = []
elif PIP_COUNTS_COMMENTS:
# Comment: count as normal req but have no hashes.
yield []
return next(islice(hash_lists(path), line_number - 1, None))
|
[
"def",
"hashes_above",
"(",
"path",
",",
"line_number",
")",
":",
"def",
"hash_lists",
"(",
"path",
")",
":",
"\"\"\"Yield lists of hashes appearing between non-comment lines.\n\n The lists will be in order of appearance and, for each non-empty\n list, their place in the results will coincide with that of the\n line number of the corresponding result from `parse_requirements`\n (which changed in pip 7.0 to not count comments).\n\n \"\"\"",
"hashes",
"=",
"[",
"]",
"with",
"open",
"(",
"path",
")",
"as",
"file",
":",
"for",
"lineno",
",",
"line",
"in",
"enumerate",
"(",
"file",
",",
"1",
")",
":",
"match",
"=",
"HASH_COMMENT_RE",
".",
"match",
"(",
"line",
")",
"if",
"match",
":",
"# Accumulate this hash.",
"hashes",
".",
"append",
"(",
"match",
".",
"groupdict",
"(",
")",
"[",
"'hash'",
"]",
")",
"if",
"not",
"IGNORED_LINE_RE",
".",
"match",
"(",
"line",
")",
":",
"yield",
"hashes",
"# Report hashes seen so far.",
"hashes",
"=",
"[",
"]",
"elif",
"PIP_COUNTS_COMMENTS",
":",
"# Comment: count as normal req but have no hashes.",
"yield",
"[",
"]",
"return",
"next",
"(",
"islice",
"(",
"hash_lists",
"(",
"path",
")",
",",
"line_number",
"-",
"1",
",",
"None",
")",
")"
] |
Yield hashes from contiguous comment lines before line ``line_number``.
|
[
"Yield",
"hashes",
"from",
"contiguous",
"comment",
"lines",
"before",
"line",
"line_number",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L174-L200
|
erikrose/peep
|
peep.py
|
run_pip
|
def run_pip(initial_args):
"""Delegate to pip the given args (starting with the subcommand), and raise
``PipException`` if something goes wrong."""
status_code = pip.main(initial_args)
# Clear out the registrations in the pip "logger" singleton. Otherwise,
# loggers keep getting appended to it with every run. Pip assumes only one
# command invocation will happen per interpreter lifetime.
logger.consumers = []
if status_code:
raise PipException(status_code)
|
python
|
def run_pip(initial_args):
"""Delegate to pip the given args (starting with the subcommand), and raise
``PipException`` if something goes wrong."""
status_code = pip.main(initial_args)
# Clear out the registrations in the pip "logger" singleton. Otherwise,
# loggers keep getting appended to it with every run. Pip assumes only one
# command invocation will happen per interpreter lifetime.
logger.consumers = []
if status_code:
raise PipException(status_code)
|
[
"def",
"run_pip",
"(",
"initial_args",
")",
":",
"status_code",
"=",
"pip",
".",
"main",
"(",
"initial_args",
")",
"# Clear out the registrations in the pip \"logger\" singleton. Otherwise,",
"# loggers keep getting appended to it with every run. Pip assumes only one",
"# command invocation will happen per interpreter lifetime.",
"logger",
".",
"consumers",
"=",
"[",
"]",
"if",
"status_code",
":",
"raise",
"PipException",
"(",
"status_code",
")"
] |
Delegate to pip the given args (starting with the subcommand), and raise
``PipException`` if something goes wrong.
|
[
"Delegate",
"to",
"pip",
"the",
"given",
"args",
"(",
"starting",
"with",
"the",
"subcommand",
")",
"and",
"raise",
"PipException",
"if",
"something",
"goes",
"wrong",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L203-L214
|
erikrose/peep
|
peep.py
|
hash_of_file
|
def hash_of_file(path):
"""Return the hash of a downloaded file."""
with open(path, 'rb') as archive:
sha = sha256()
while True:
data = archive.read(2 ** 20)
if not data:
break
sha.update(data)
return encoded_hash(sha)
|
python
|
def hash_of_file(path):
"""Return the hash of a downloaded file."""
with open(path, 'rb') as archive:
sha = sha256()
while True:
data = archive.read(2 ** 20)
if not data:
break
sha.update(data)
return encoded_hash(sha)
|
[
"def",
"hash_of_file",
"(",
"path",
")",
":",
"with",
"open",
"(",
"path",
",",
"'rb'",
")",
"as",
"archive",
":",
"sha",
"=",
"sha256",
"(",
")",
"while",
"True",
":",
"data",
"=",
"archive",
".",
"read",
"(",
"2",
"**",
"20",
")",
"if",
"not",
"data",
":",
"break",
"sha",
".",
"update",
"(",
"data",
")",
"return",
"encoded_hash",
"(",
"sha",
")"
] |
Return the hash of a downloaded file.
|
[
"Return",
"the",
"hash",
"of",
"a",
"downloaded",
"file",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L217-L226
|
erikrose/peep
|
peep.py
|
requirement_args
|
def requirement_args(argv, want_paths=False, want_other=False):
"""Return an iterable of filtered arguments.
:arg argv: Arguments, starting after the subcommand
:arg want_paths: If True, the returned iterable includes the paths to any
requirements files following a ``-r`` or ``--requirement`` option.
:arg want_other: If True, the returned iterable includes the args that are
not a requirement-file path or a ``-r`` or ``--requirement`` flag.
"""
was_r = False
for arg in argv:
# Allow for requirements files named "-r", don't freak out if there's a
# trailing "-r", etc.
if was_r:
if want_paths:
yield arg
was_r = False
elif arg in ['-r', '--requirement']:
was_r = True
else:
if want_other:
yield arg
|
python
|
def requirement_args(argv, want_paths=False, want_other=False):
"""Return an iterable of filtered arguments.
:arg argv: Arguments, starting after the subcommand
:arg want_paths: If True, the returned iterable includes the paths to any
requirements files following a ``-r`` or ``--requirement`` option.
:arg want_other: If True, the returned iterable includes the args that are
not a requirement-file path or a ``-r`` or ``--requirement`` flag.
"""
was_r = False
for arg in argv:
# Allow for requirements files named "-r", don't freak out if there's a
# trailing "-r", etc.
if was_r:
if want_paths:
yield arg
was_r = False
elif arg in ['-r', '--requirement']:
was_r = True
else:
if want_other:
yield arg
|
[
"def",
"requirement_args",
"(",
"argv",
",",
"want_paths",
"=",
"False",
",",
"want_other",
"=",
"False",
")",
":",
"was_r",
"=",
"False",
"for",
"arg",
"in",
"argv",
":",
"# Allow for requirements files named \"-r\", don't freak out if there's a",
"# trailing \"-r\", etc.",
"if",
"was_r",
":",
"if",
"want_paths",
":",
"yield",
"arg",
"was_r",
"=",
"False",
"elif",
"arg",
"in",
"[",
"'-r'",
",",
"'--requirement'",
"]",
":",
"was_r",
"=",
"True",
"else",
":",
"if",
"want_other",
":",
"yield",
"arg"
] |
Return an iterable of filtered arguments.
:arg argv: Arguments, starting after the subcommand
:arg want_paths: If True, the returned iterable includes the paths to any
requirements files following a ``-r`` or ``--requirement`` option.
:arg want_other: If True, the returned iterable includes the args that are
not a requirement-file path or a ``-r`` or ``--requirement`` flag.
|
[
"Return",
"an",
"iterable",
"of",
"filtered",
"arguments",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L247-L269
|
erikrose/peep
|
peep.py
|
peep_hash
|
def peep_hash(argv):
"""Return the peep hash of one or more files, returning a shell status code
or raising a PipException.
:arg argv: The commandline args, starting after the subcommand
"""
parser = OptionParser(
usage='usage: %prog hash file [file ...]',
description='Print a peep hash line for one or more files: for '
'example, "# sha256: '
'oz42dZy6Gowxw8AelDtO4gRgTW_xPdooH484k7I5EOY".')
_, paths = parser.parse_args(args=argv)
if paths:
for path in paths:
print('# sha256:', hash_of_file(path))
return ITS_FINE_ITS_FINE
else:
parser.print_usage()
return COMMAND_LINE_ERROR
|
python
|
def peep_hash(argv):
"""Return the peep hash of one or more files, returning a shell status code
or raising a PipException.
:arg argv: The commandline args, starting after the subcommand
"""
parser = OptionParser(
usage='usage: %prog hash file [file ...]',
description='Print a peep hash line for one or more files: for '
'example, "# sha256: '
'oz42dZy6Gowxw8AelDtO4gRgTW_xPdooH484k7I5EOY".')
_, paths = parser.parse_args(args=argv)
if paths:
for path in paths:
print('# sha256:', hash_of_file(path))
return ITS_FINE_ITS_FINE
else:
parser.print_usage()
return COMMAND_LINE_ERROR
|
[
"def",
"peep_hash",
"(",
"argv",
")",
":",
"parser",
"=",
"OptionParser",
"(",
"usage",
"=",
"'usage: %prog hash file [file ...]'",
",",
"description",
"=",
"'Print a peep hash line for one or more files: for '",
"'example, \"# sha256: '",
"'oz42dZy6Gowxw8AelDtO4gRgTW_xPdooH484k7I5EOY\".'",
")",
"_",
",",
"paths",
"=",
"parser",
".",
"parse_args",
"(",
"args",
"=",
"argv",
")",
"if",
"paths",
":",
"for",
"path",
"in",
"paths",
":",
"print",
"(",
"'# sha256:'",
",",
"hash_of_file",
"(",
"path",
")",
")",
"return",
"ITS_FINE_ITS_FINE",
"else",
":",
"parser",
".",
"print_usage",
"(",
")",
"return",
"COMMAND_LINE_ERROR"
] |
Return the peep hash of one or more files, returning a shell status code
or raising a PipException.
:arg argv: The commandline args, starting after the subcommand
|
[
"Return",
"the",
"peep",
"hash",
"of",
"one",
"or",
"more",
"files",
"returning",
"a",
"shell",
"status",
"code",
"or",
"raising",
"a",
"PipException",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L287-L306
|
erikrose/peep
|
peep.py
|
memoize
|
def memoize(func):
"""Memoize a method that should return the same result every time on a
given instance.
"""
@wraps(func)
def memoizer(self):
if not hasattr(self, '_cache'):
self._cache = {}
if func.__name__ not in self._cache:
self._cache[func.__name__] = func(self)
return self._cache[func.__name__]
return memoizer
|
python
|
def memoize(func):
"""Memoize a method that should return the same result every time on a
given instance.
"""
@wraps(func)
def memoizer(self):
if not hasattr(self, '_cache'):
self._cache = {}
if func.__name__ not in self._cache:
self._cache[func.__name__] = func(self)
return self._cache[func.__name__]
return memoizer
|
[
"def",
"memoize",
"(",
"func",
")",
":",
"@",
"wraps",
"(",
"func",
")",
"def",
"memoizer",
"(",
"self",
")",
":",
"if",
"not",
"hasattr",
"(",
"self",
",",
"'_cache'",
")",
":",
"self",
".",
"_cache",
"=",
"{",
"}",
"if",
"func",
".",
"__name__",
"not",
"in",
"self",
".",
"_cache",
":",
"self",
".",
"_cache",
"[",
"func",
".",
"__name__",
"]",
"=",
"func",
"(",
"self",
")",
"return",
"self",
".",
"_cache",
"[",
"func",
".",
"__name__",
"]",
"return",
"memoizer"
] |
Memoize a method that should return the same result every time on a
given instance.
|
[
"Memoize",
"a",
"method",
"that",
"should",
"return",
"the",
"same",
"result",
"every",
"time",
"on",
"a",
"given",
"instance",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L321-L333
|
erikrose/peep
|
peep.py
|
package_finder
|
def package_finder(argv):
"""Return a PackageFinder respecting command-line options.
:arg argv: Everything after the subcommand
"""
# We instantiate an InstallCommand and then use some of its private
# machinery--its arg parser--for our own purposes, like a virus. This
# approach is portable across many pip versions, where more fine-grained
# ones are not. Ignoring options that don't exist on the parser (for
# instance, --use-wheel) gives us a straightforward method of backward
# compatibility.
try:
command = InstallCommand()
except TypeError:
# This is likely pip 1.3.0's "__init__() takes exactly 2 arguments (1
# given)" error. In that version, InstallCommand takes a top=level
# parser passed in from outside.
from pip.baseparser import create_main_parser
command = InstallCommand(create_main_parser())
# The downside is that it essentially ruins the InstallCommand class for
# further use. Calling out to pip.main() within the same interpreter, for
# example, would result in arguments parsed this time turning up there.
# Thus, we deepcopy the arg parser so we don't trash its singletons. Of
# course, deepcopy doesn't work on these objects, because they contain
# uncopyable regex patterns, so we pickle and unpickle instead. Fun!
options, _ = loads(dumps(command.parser)).parse_args(argv)
# Carry over PackageFinder kwargs that have [about] the same names as
# options attr names:
possible_options = [
'find_links',
FORMAT_CONTROL_ARG,
('allow_all_prereleases', 'pre'),
'process_dependency_links'
]
kwargs = {}
for option in possible_options:
kw, attr = option if isinstance(option, tuple) else (option, option)
value = getattr(options, attr, MARKER)
if value is not MARKER:
kwargs[kw] = value
# Figure out index_urls:
index_urls = [options.index_url] + options.extra_index_urls
if options.no_index:
index_urls = []
index_urls += getattr(options, 'mirrors', [])
# If pip is new enough to have a PipSession, initialize one, since
# PackageFinder requires it:
if hasattr(command, '_build_session'):
kwargs['session'] = command._build_session(options)
return PackageFinder(index_urls=index_urls, **kwargs)
|
python
|
def package_finder(argv):
"""Return a PackageFinder respecting command-line options.
:arg argv: Everything after the subcommand
"""
# We instantiate an InstallCommand and then use some of its private
# machinery--its arg parser--for our own purposes, like a virus. This
# approach is portable across many pip versions, where more fine-grained
# ones are not. Ignoring options that don't exist on the parser (for
# instance, --use-wheel) gives us a straightforward method of backward
# compatibility.
try:
command = InstallCommand()
except TypeError:
# This is likely pip 1.3.0's "__init__() takes exactly 2 arguments (1
# given)" error. In that version, InstallCommand takes a top=level
# parser passed in from outside.
from pip.baseparser import create_main_parser
command = InstallCommand(create_main_parser())
# The downside is that it essentially ruins the InstallCommand class for
# further use. Calling out to pip.main() within the same interpreter, for
# example, would result in arguments parsed this time turning up there.
# Thus, we deepcopy the arg parser so we don't trash its singletons. Of
# course, deepcopy doesn't work on these objects, because they contain
# uncopyable regex patterns, so we pickle and unpickle instead. Fun!
options, _ = loads(dumps(command.parser)).parse_args(argv)
# Carry over PackageFinder kwargs that have [about] the same names as
# options attr names:
possible_options = [
'find_links',
FORMAT_CONTROL_ARG,
('allow_all_prereleases', 'pre'),
'process_dependency_links'
]
kwargs = {}
for option in possible_options:
kw, attr = option if isinstance(option, tuple) else (option, option)
value = getattr(options, attr, MARKER)
if value is not MARKER:
kwargs[kw] = value
# Figure out index_urls:
index_urls = [options.index_url] + options.extra_index_urls
if options.no_index:
index_urls = []
index_urls += getattr(options, 'mirrors', [])
# If pip is new enough to have a PipSession, initialize one, since
# PackageFinder requires it:
if hasattr(command, '_build_session'):
kwargs['session'] = command._build_session(options)
return PackageFinder(index_urls=index_urls, **kwargs)
|
[
"def",
"package_finder",
"(",
"argv",
")",
":",
"# We instantiate an InstallCommand and then use some of its private",
"# machinery--its arg parser--for our own purposes, like a virus. This",
"# approach is portable across many pip versions, where more fine-grained",
"# ones are not. Ignoring options that don't exist on the parser (for",
"# instance, --use-wheel) gives us a straightforward method of backward",
"# compatibility.",
"try",
":",
"command",
"=",
"InstallCommand",
"(",
")",
"except",
"TypeError",
":",
"# This is likely pip 1.3.0's \"__init__() takes exactly 2 arguments (1",
"# given)\" error. In that version, InstallCommand takes a top=level",
"# parser passed in from outside.",
"from",
"pip",
".",
"baseparser",
"import",
"create_main_parser",
"command",
"=",
"InstallCommand",
"(",
"create_main_parser",
"(",
")",
")",
"# The downside is that it essentially ruins the InstallCommand class for",
"# further use. Calling out to pip.main() within the same interpreter, for",
"# example, would result in arguments parsed this time turning up there.",
"# Thus, we deepcopy the arg parser so we don't trash its singletons. Of",
"# course, deepcopy doesn't work on these objects, because they contain",
"# uncopyable regex patterns, so we pickle and unpickle instead. Fun!",
"options",
",",
"_",
"=",
"loads",
"(",
"dumps",
"(",
"command",
".",
"parser",
")",
")",
".",
"parse_args",
"(",
"argv",
")",
"# Carry over PackageFinder kwargs that have [about] the same names as",
"# options attr names:",
"possible_options",
"=",
"[",
"'find_links'",
",",
"FORMAT_CONTROL_ARG",
",",
"(",
"'allow_all_prereleases'",
",",
"'pre'",
")",
",",
"'process_dependency_links'",
"]",
"kwargs",
"=",
"{",
"}",
"for",
"option",
"in",
"possible_options",
":",
"kw",
",",
"attr",
"=",
"option",
"if",
"isinstance",
"(",
"option",
",",
"tuple",
")",
"else",
"(",
"option",
",",
"option",
")",
"value",
"=",
"getattr",
"(",
"options",
",",
"attr",
",",
"MARKER",
")",
"if",
"value",
"is",
"not",
"MARKER",
":",
"kwargs",
"[",
"kw",
"]",
"=",
"value",
"# Figure out index_urls:",
"index_urls",
"=",
"[",
"options",
".",
"index_url",
"]",
"+",
"options",
".",
"extra_index_urls",
"if",
"options",
".",
"no_index",
":",
"index_urls",
"=",
"[",
"]",
"index_urls",
"+=",
"getattr",
"(",
"options",
",",
"'mirrors'",
",",
"[",
"]",
")",
"# If pip is new enough to have a PipSession, initialize one, since",
"# PackageFinder requires it:",
"if",
"hasattr",
"(",
"command",
",",
"'_build_session'",
")",
":",
"kwargs",
"[",
"'session'",
"]",
"=",
"command",
".",
"_build_session",
"(",
"options",
")",
"return",
"PackageFinder",
"(",
"index_urls",
"=",
"index_urls",
",",
"*",
"*",
"kwargs",
")"
] |
Return a PackageFinder respecting command-line options.
:arg argv: Everything after the subcommand
|
[
"Return",
"a",
"PackageFinder",
"respecting",
"command",
"-",
"line",
"options",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L336-L390
|
erikrose/peep
|
peep.py
|
bucket
|
def bucket(things, key):
"""Return a map of key -> list of things."""
ret = defaultdict(list)
for thing in things:
ret[key(thing)].append(thing)
return ret
|
python
|
def bucket(things, key):
"""Return a map of key -> list of things."""
ret = defaultdict(list)
for thing in things:
ret[key(thing)].append(thing)
return ret
|
[
"def",
"bucket",
"(",
"things",
",",
"key",
")",
":",
"ret",
"=",
"defaultdict",
"(",
"list",
")",
"for",
"thing",
"in",
"things",
":",
"ret",
"[",
"key",
"(",
"thing",
")",
"]",
".",
"append",
"(",
"thing",
")",
"return",
"ret"
] |
Return a map of key -> list of things.
|
[
"Return",
"a",
"map",
"of",
"key",
"-",
">",
"list",
"of",
"things",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L793-L798
|
erikrose/peep
|
peep.py
|
first_every_last
|
def first_every_last(iterable, first, every, last):
"""Execute something before the first item of iter, something else for each
item, and a third thing after the last.
If there are no items in the iterable, don't execute anything.
"""
did_first = False
for item in iterable:
if not did_first:
did_first = True
first(item)
every(item)
if did_first:
last(item)
|
python
|
def first_every_last(iterable, first, every, last):
"""Execute something before the first item of iter, something else for each
item, and a third thing after the last.
If there are no items in the iterable, don't execute anything.
"""
did_first = False
for item in iterable:
if not did_first:
did_first = True
first(item)
every(item)
if did_first:
last(item)
|
[
"def",
"first_every_last",
"(",
"iterable",
",",
"first",
",",
"every",
",",
"last",
")",
":",
"did_first",
"=",
"False",
"for",
"item",
"in",
"iterable",
":",
"if",
"not",
"did_first",
":",
"did_first",
"=",
"True",
"first",
"(",
"item",
")",
"every",
"(",
"item",
")",
"if",
"did_first",
":",
"last",
"(",
"item",
")"
] |
Execute something before the first item of iter, something else for each
item, and a third thing after the last.
If there are no items in the iterable, don't execute anything.
|
[
"Execute",
"something",
"before",
"the",
"first",
"item",
"of",
"iter",
"something",
"else",
"for",
"each",
"item",
"and",
"a",
"third",
"thing",
"after",
"the",
"last",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L801-L815
|
erikrose/peep
|
peep.py
|
downloaded_reqs_from_path
|
def downloaded_reqs_from_path(path, argv):
"""Return a list of DownloadedReqs representing the requirements parsed
out of a given requirements file.
:arg path: The path to the requirements file
:arg argv: The commandline args, starting after the subcommand
"""
finder = package_finder(argv)
return [DownloadedReq(req, argv, finder) for req in
_parse_requirements(path, finder)]
|
python
|
def downloaded_reqs_from_path(path, argv):
"""Return a list of DownloadedReqs representing the requirements parsed
out of a given requirements file.
:arg path: The path to the requirements file
:arg argv: The commandline args, starting after the subcommand
"""
finder = package_finder(argv)
return [DownloadedReq(req, argv, finder) for req in
_parse_requirements(path, finder)]
|
[
"def",
"downloaded_reqs_from_path",
"(",
"path",
",",
"argv",
")",
":",
"finder",
"=",
"package_finder",
"(",
"argv",
")",
"return",
"[",
"DownloadedReq",
"(",
"req",
",",
"argv",
",",
"finder",
")",
"for",
"req",
"in",
"_parse_requirements",
"(",
"path",
",",
"finder",
")",
"]"
] |
Return a list of DownloadedReqs representing the requirements parsed
out of a given requirements file.
:arg path: The path to the requirements file
:arg argv: The commandline args, starting after the subcommand
|
[
"Return",
"a",
"list",
"of",
"DownloadedReqs",
"representing",
"the",
"requirements",
"parsed",
"out",
"of",
"a",
"given",
"requirements",
"file",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L834-L844
|
erikrose/peep
|
peep.py
|
peep_install
|
def peep_install(argv):
"""Perform the ``peep install`` subcommand, returning a shell status code
or raising a PipException.
:arg argv: The commandline args, starting after the subcommand
"""
output = []
out = output.append
reqs = []
try:
req_paths = list(requirement_args(argv, want_paths=True))
if not req_paths:
out("You have to specify one or more requirements files with the -r option, because\n"
"otherwise there's nowhere for peep to look up the hashes.\n")
return COMMAND_LINE_ERROR
# We're a "peep install" command, and we have some requirement paths.
reqs = list(chain.from_iterable(
downloaded_reqs_from_path(path, argv)
for path in req_paths))
buckets = bucket(reqs, lambda r: r.__class__)
# Skip a line after pip's "Cleaning up..." so the important stuff
# stands out:
if any(buckets[b] for b in ERROR_CLASSES):
out('\n')
printers = (lambda r: out(r.head()),
lambda r: out(r.error() + '\n'),
lambda r: out(r.foot()))
for c in ERROR_CLASSES:
first_every_last(buckets[c], *printers)
if any(buckets[b] for b in ERROR_CLASSES):
out('-------------------------------\n'
'Not proceeding to installation.\n')
return SOMETHING_WENT_WRONG
else:
for req in buckets[InstallableReq]:
req.install()
first_every_last(buckets[SatisfiedReq], *printers)
return ITS_FINE_ITS_FINE
except (UnsupportedRequirementError, InstallationError, DownloadError) as exc:
out(str(exc))
return SOMETHING_WENT_WRONG
finally:
for req in reqs:
req.dispose()
print(''.join(output))
|
python
|
def peep_install(argv):
"""Perform the ``peep install`` subcommand, returning a shell status code
or raising a PipException.
:arg argv: The commandline args, starting after the subcommand
"""
output = []
out = output.append
reqs = []
try:
req_paths = list(requirement_args(argv, want_paths=True))
if not req_paths:
out("You have to specify one or more requirements files with the -r option, because\n"
"otherwise there's nowhere for peep to look up the hashes.\n")
return COMMAND_LINE_ERROR
# We're a "peep install" command, and we have some requirement paths.
reqs = list(chain.from_iterable(
downloaded_reqs_from_path(path, argv)
for path in req_paths))
buckets = bucket(reqs, lambda r: r.__class__)
# Skip a line after pip's "Cleaning up..." so the important stuff
# stands out:
if any(buckets[b] for b in ERROR_CLASSES):
out('\n')
printers = (lambda r: out(r.head()),
lambda r: out(r.error() + '\n'),
lambda r: out(r.foot()))
for c in ERROR_CLASSES:
first_every_last(buckets[c], *printers)
if any(buckets[b] for b in ERROR_CLASSES):
out('-------------------------------\n'
'Not proceeding to installation.\n')
return SOMETHING_WENT_WRONG
else:
for req in buckets[InstallableReq]:
req.install()
first_every_last(buckets[SatisfiedReq], *printers)
return ITS_FINE_ITS_FINE
except (UnsupportedRequirementError, InstallationError, DownloadError) as exc:
out(str(exc))
return SOMETHING_WENT_WRONG
finally:
for req in reqs:
req.dispose()
print(''.join(output))
|
[
"def",
"peep_install",
"(",
"argv",
")",
":",
"output",
"=",
"[",
"]",
"out",
"=",
"output",
".",
"append",
"reqs",
"=",
"[",
"]",
"try",
":",
"req_paths",
"=",
"list",
"(",
"requirement_args",
"(",
"argv",
",",
"want_paths",
"=",
"True",
")",
")",
"if",
"not",
"req_paths",
":",
"out",
"(",
"\"You have to specify one or more requirements files with the -r option, because\\n\"",
"\"otherwise there's nowhere for peep to look up the hashes.\\n\"",
")",
"return",
"COMMAND_LINE_ERROR",
"# We're a \"peep install\" command, and we have some requirement paths.",
"reqs",
"=",
"list",
"(",
"chain",
".",
"from_iterable",
"(",
"downloaded_reqs_from_path",
"(",
"path",
",",
"argv",
")",
"for",
"path",
"in",
"req_paths",
")",
")",
"buckets",
"=",
"bucket",
"(",
"reqs",
",",
"lambda",
"r",
":",
"r",
".",
"__class__",
")",
"# Skip a line after pip's \"Cleaning up...\" so the important stuff",
"# stands out:",
"if",
"any",
"(",
"buckets",
"[",
"b",
"]",
"for",
"b",
"in",
"ERROR_CLASSES",
")",
":",
"out",
"(",
"'\\n'",
")",
"printers",
"=",
"(",
"lambda",
"r",
":",
"out",
"(",
"r",
".",
"head",
"(",
")",
")",
",",
"lambda",
"r",
":",
"out",
"(",
"r",
".",
"error",
"(",
")",
"+",
"'\\n'",
")",
",",
"lambda",
"r",
":",
"out",
"(",
"r",
".",
"foot",
"(",
")",
")",
")",
"for",
"c",
"in",
"ERROR_CLASSES",
":",
"first_every_last",
"(",
"buckets",
"[",
"c",
"]",
",",
"*",
"printers",
")",
"if",
"any",
"(",
"buckets",
"[",
"b",
"]",
"for",
"b",
"in",
"ERROR_CLASSES",
")",
":",
"out",
"(",
"'-------------------------------\\n'",
"'Not proceeding to installation.\\n'",
")",
"return",
"SOMETHING_WENT_WRONG",
"else",
":",
"for",
"req",
"in",
"buckets",
"[",
"InstallableReq",
"]",
":",
"req",
".",
"install",
"(",
")",
"first_every_last",
"(",
"buckets",
"[",
"SatisfiedReq",
"]",
",",
"*",
"printers",
")",
"return",
"ITS_FINE_ITS_FINE",
"except",
"(",
"UnsupportedRequirementError",
",",
"InstallationError",
",",
"DownloadError",
")",
"as",
"exc",
":",
"out",
"(",
"str",
"(",
"exc",
")",
")",
"return",
"SOMETHING_WENT_WRONG",
"finally",
":",
"for",
"req",
"in",
"reqs",
":",
"req",
".",
"dispose",
"(",
")",
"print",
"(",
"''",
".",
"join",
"(",
"output",
")",
")"
] |
Perform the ``peep install`` subcommand, returning a shell status code
or raising a PipException.
:arg argv: The commandline args, starting after the subcommand
|
[
"Perform",
"the",
"peep",
"install",
"subcommand",
"returning",
"a",
"shell",
"status",
"code",
"or",
"raising",
"a",
"PipException",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L847-L898
|
erikrose/peep
|
peep.py
|
peep_port
|
def peep_port(paths):
"""Convert a peep requirements file to one compatble with pip-8 hashing.
Loses comments and tromps on URLs, so the result will need a little manual
massaging, but the hard part--the hash conversion--is done for you.
"""
if not paths:
print('Please specify one or more requirements files so I have '
'something to port.\n')
return COMMAND_LINE_ERROR
comes_from = None
for req in chain.from_iterable(
_parse_requirements(path, package_finder(argv)) for path in paths):
req_path, req_line = path_and_line(req)
hashes = [hexlify(urlsafe_b64decode((hash + '=').encode('ascii'))).decode('ascii')
for hash in hashes_above(req_path, req_line)]
if req_path != comes_from:
print()
print('# from %s' % req_path)
print()
comes_from = req_path
if not hashes:
print(req.req)
else:
print('%s' % (req.link if getattr(req, 'link', None) else req.req), end='')
for hash in hashes:
print(' \\')
print(' --hash=sha256:%s' % hash, end='')
print()
|
python
|
def peep_port(paths):
"""Convert a peep requirements file to one compatble with pip-8 hashing.
Loses comments and tromps on URLs, so the result will need a little manual
massaging, but the hard part--the hash conversion--is done for you.
"""
if not paths:
print('Please specify one or more requirements files so I have '
'something to port.\n')
return COMMAND_LINE_ERROR
comes_from = None
for req in chain.from_iterable(
_parse_requirements(path, package_finder(argv)) for path in paths):
req_path, req_line = path_and_line(req)
hashes = [hexlify(urlsafe_b64decode((hash + '=').encode('ascii'))).decode('ascii')
for hash in hashes_above(req_path, req_line)]
if req_path != comes_from:
print()
print('# from %s' % req_path)
print()
comes_from = req_path
if not hashes:
print(req.req)
else:
print('%s' % (req.link if getattr(req, 'link', None) else req.req), end='')
for hash in hashes:
print(' \\')
print(' --hash=sha256:%s' % hash, end='')
print()
|
[
"def",
"peep_port",
"(",
"paths",
")",
":",
"if",
"not",
"paths",
":",
"print",
"(",
"'Please specify one or more requirements files so I have '",
"'something to port.\\n'",
")",
"return",
"COMMAND_LINE_ERROR",
"comes_from",
"=",
"None",
"for",
"req",
"in",
"chain",
".",
"from_iterable",
"(",
"_parse_requirements",
"(",
"path",
",",
"package_finder",
"(",
"argv",
")",
")",
"for",
"path",
"in",
"paths",
")",
":",
"req_path",
",",
"req_line",
"=",
"path_and_line",
"(",
"req",
")",
"hashes",
"=",
"[",
"hexlify",
"(",
"urlsafe_b64decode",
"(",
"(",
"hash",
"+",
"'='",
")",
".",
"encode",
"(",
"'ascii'",
")",
")",
")",
".",
"decode",
"(",
"'ascii'",
")",
"for",
"hash",
"in",
"hashes_above",
"(",
"req_path",
",",
"req_line",
")",
"]",
"if",
"req_path",
"!=",
"comes_from",
":",
"print",
"(",
")",
"print",
"(",
"'# from %s'",
"%",
"req_path",
")",
"print",
"(",
")",
"comes_from",
"=",
"req_path",
"if",
"not",
"hashes",
":",
"print",
"(",
"req",
".",
"req",
")",
"else",
":",
"print",
"(",
"'%s'",
"%",
"(",
"req",
".",
"link",
"if",
"getattr",
"(",
"req",
",",
"'link'",
",",
"None",
")",
"else",
"req",
".",
"req",
")",
",",
"end",
"=",
"''",
")",
"for",
"hash",
"in",
"hashes",
":",
"print",
"(",
"' \\\\'",
")",
"print",
"(",
"' --hash=sha256:%s'",
"%",
"hash",
",",
"end",
"=",
"''",
")",
"print",
"(",
")"
] |
Convert a peep requirements file to one compatble with pip-8 hashing.
Loses comments and tromps on URLs, so the result will need a little manual
massaging, but the hard part--the hash conversion--is done for you.
|
[
"Convert",
"a",
"peep",
"requirements",
"file",
"to",
"one",
"compatble",
"with",
"pip",
"-",
"8",
"hashing",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L901-L932
|
erikrose/peep
|
peep.py
|
main
|
def main():
"""Be the top-level entrypoint. Return a shell status code."""
commands = {'hash': peep_hash,
'install': peep_install,
'port': peep_port}
try:
if len(argv) >= 2 and argv[1] in commands:
return commands[argv[1]](argv[2:])
else:
# Fall through to top-level pip main() for everything else:
return pip.main()
except PipException as exc:
return exc.error_code
|
python
|
def main():
"""Be the top-level entrypoint. Return a shell status code."""
commands = {'hash': peep_hash,
'install': peep_install,
'port': peep_port}
try:
if len(argv) >= 2 and argv[1] in commands:
return commands[argv[1]](argv[2:])
else:
# Fall through to top-level pip main() for everything else:
return pip.main()
except PipException as exc:
return exc.error_code
|
[
"def",
"main",
"(",
")",
":",
"commands",
"=",
"{",
"'hash'",
":",
"peep_hash",
",",
"'install'",
":",
"peep_install",
",",
"'port'",
":",
"peep_port",
"}",
"try",
":",
"if",
"len",
"(",
"argv",
")",
">=",
"2",
"and",
"argv",
"[",
"1",
"]",
"in",
"commands",
":",
"return",
"commands",
"[",
"argv",
"[",
"1",
"]",
"]",
"(",
"argv",
"[",
"2",
":",
"]",
")",
"else",
":",
"# Fall through to top-level pip main() for everything else:",
"return",
"pip",
".",
"main",
"(",
")",
"except",
"PipException",
"as",
"exc",
":",
"return",
"exc",
".",
"error_code"
] |
Be the top-level entrypoint. Return a shell status code.
|
[
"Be",
"the",
"top",
"-",
"level",
"entrypoint",
".",
"Return",
"a",
"shell",
"status",
"code",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L935-L947
|
erikrose/peep
|
peep.py
|
DownloadedReq._version
|
def _version(self):
"""Deduce the version number of the downloaded package from its filename."""
# TODO: Can we delete this method and just print the line from the
# reqs file verbatim instead?
def version_of_archive(filename, package_name):
# Since we know the project_name, we can strip that off the left, strip
# any archive extensions off the right, and take the rest as the
# version.
for ext in ARCHIVE_EXTENSIONS:
if filename.endswith(ext):
filename = filename[:-len(ext)]
break
# Handle github sha tarball downloads.
if is_git_sha(filename):
filename = package_name + '-' + filename
if not filename.lower().replace('_', '-').startswith(package_name.lower()):
# TODO: Should we replace runs of [^a-zA-Z0-9.], not just _, with -?
give_up(filename, package_name)
return filename[len(package_name) + 1:] # Strip off '-' before version.
def version_of_wheel(filename, package_name):
# For Wheel files (http://legacy.python.org/dev/peps/pep-0427/#file-
# name-convention) we know the format bits are '-' separated.
whl_package_name, version, _rest = filename.split('-', 2)
# Do the alteration to package_name from PEP 427:
our_package_name = re.sub(r'[^\w\d.]+', '_', package_name, re.UNICODE)
if whl_package_name != our_package_name:
give_up(filename, whl_package_name)
return version
def give_up(filename, package_name):
raise RuntimeError("The archive '%s' didn't start with the package name "
"'%s', so I couldn't figure out the version number. "
"My bad; improve me." %
(filename, package_name))
get_version = (version_of_wheel
if self._downloaded_filename().endswith('.whl')
else version_of_archive)
return get_version(self._downloaded_filename(), self._project_name())
|
python
|
def _version(self):
"""Deduce the version number of the downloaded package from its filename."""
# TODO: Can we delete this method and just print the line from the
# reqs file verbatim instead?
def version_of_archive(filename, package_name):
# Since we know the project_name, we can strip that off the left, strip
# any archive extensions off the right, and take the rest as the
# version.
for ext in ARCHIVE_EXTENSIONS:
if filename.endswith(ext):
filename = filename[:-len(ext)]
break
# Handle github sha tarball downloads.
if is_git_sha(filename):
filename = package_name + '-' + filename
if not filename.lower().replace('_', '-').startswith(package_name.lower()):
# TODO: Should we replace runs of [^a-zA-Z0-9.], not just _, with -?
give_up(filename, package_name)
return filename[len(package_name) + 1:] # Strip off '-' before version.
def version_of_wheel(filename, package_name):
# For Wheel files (http://legacy.python.org/dev/peps/pep-0427/#file-
# name-convention) we know the format bits are '-' separated.
whl_package_name, version, _rest = filename.split('-', 2)
# Do the alteration to package_name from PEP 427:
our_package_name = re.sub(r'[^\w\d.]+', '_', package_name, re.UNICODE)
if whl_package_name != our_package_name:
give_up(filename, whl_package_name)
return version
def give_up(filename, package_name):
raise RuntimeError("The archive '%s' didn't start with the package name "
"'%s', so I couldn't figure out the version number. "
"My bad; improve me." %
(filename, package_name))
get_version = (version_of_wheel
if self._downloaded_filename().endswith('.whl')
else version_of_archive)
return get_version(self._downloaded_filename(), self._project_name())
|
[
"def",
"_version",
"(",
"self",
")",
":",
"# TODO: Can we delete this method and just print the line from the",
"# reqs file verbatim instead?",
"def",
"version_of_archive",
"(",
"filename",
",",
"package_name",
")",
":",
"# Since we know the project_name, we can strip that off the left, strip",
"# any archive extensions off the right, and take the rest as the",
"# version.",
"for",
"ext",
"in",
"ARCHIVE_EXTENSIONS",
":",
"if",
"filename",
".",
"endswith",
"(",
"ext",
")",
":",
"filename",
"=",
"filename",
"[",
":",
"-",
"len",
"(",
"ext",
")",
"]",
"break",
"# Handle github sha tarball downloads.",
"if",
"is_git_sha",
"(",
"filename",
")",
":",
"filename",
"=",
"package_name",
"+",
"'-'",
"+",
"filename",
"if",
"not",
"filename",
".",
"lower",
"(",
")",
".",
"replace",
"(",
"'_'",
",",
"'-'",
")",
".",
"startswith",
"(",
"package_name",
".",
"lower",
"(",
")",
")",
":",
"# TODO: Should we replace runs of [^a-zA-Z0-9.], not just _, with -?",
"give_up",
"(",
"filename",
",",
"package_name",
")",
"return",
"filename",
"[",
"len",
"(",
"package_name",
")",
"+",
"1",
":",
"]",
"# Strip off '-' before version.",
"def",
"version_of_wheel",
"(",
"filename",
",",
"package_name",
")",
":",
"# For Wheel files (http://legacy.python.org/dev/peps/pep-0427/#file-",
"# name-convention) we know the format bits are '-' separated.",
"whl_package_name",
",",
"version",
",",
"_rest",
"=",
"filename",
".",
"split",
"(",
"'-'",
",",
"2",
")",
"# Do the alteration to package_name from PEP 427:",
"our_package_name",
"=",
"re",
".",
"sub",
"(",
"r'[^\\w\\d.]+'",
",",
"'_'",
",",
"package_name",
",",
"re",
".",
"UNICODE",
")",
"if",
"whl_package_name",
"!=",
"our_package_name",
":",
"give_up",
"(",
"filename",
",",
"whl_package_name",
")",
"return",
"version",
"def",
"give_up",
"(",
"filename",
",",
"package_name",
")",
":",
"raise",
"RuntimeError",
"(",
"\"The archive '%s' didn't start with the package name \"",
"\"'%s', so I couldn't figure out the version number. \"",
"\"My bad; improve me.\"",
"%",
"(",
"filename",
",",
"package_name",
")",
")",
"get_version",
"=",
"(",
"version_of_wheel",
"if",
"self",
".",
"_downloaded_filename",
"(",
")",
".",
"endswith",
"(",
"'.whl'",
")",
"else",
"version_of_archive",
")",
"return",
"get_version",
"(",
"self",
".",
"_downloaded_filename",
"(",
")",
",",
"self",
".",
"_project_name",
"(",
")",
")"
] |
Deduce the version number of the downloaded package from its filename.
|
[
"Deduce",
"the",
"version",
"number",
"of",
"the",
"downloaded",
"package",
"from",
"its",
"filename",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L432-L471
|
erikrose/peep
|
peep.py
|
DownloadedReq._is_always_unsatisfied
|
def _is_always_unsatisfied(self):
"""Returns whether this requirement is always unsatisfied
This would happen in cases where we can't determine the version
from the filename.
"""
# If this is a github sha tarball, then it is always unsatisfied
# because the url has a commit sha in it and not the version
# number.
url = self._url()
if url:
filename = filename_from_url(url)
if filename.endswith(ARCHIVE_EXTENSIONS):
filename, ext = splitext(filename)
if is_git_sha(filename):
return True
return False
|
python
|
def _is_always_unsatisfied(self):
"""Returns whether this requirement is always unsatisfied
This would happen in cases where we can't determine the version
from the filename.
"""
# If this is a github sha tarball, then it is always unsatisfied
# because the url has a commit sha in it and not the version
# number.
url = self._url()
if url:
filename = filename_from_url(url)
if filename.endswith(ARCHIVE_EXTENSIONS):
filename, ext = splitext(filename)
if is_git_sha(filename):
return True
return False
|
[
"def",
"_is_always_unsatisfied",
"(",
"self",
")",
":",
"# If this is a github sha tarball, then it is always unsatisfied",
"# because the url has a commit sha in it and not the version",
"# number.",
"url",
"=",
"self",
".",
"_url",
"(",
")",
"if",
"url",
":",
"filename",
"=",
"filename_from_url",
"(",
"url",
")",
"if",
"filename",
".",
"endswith",
"(",
"ARCHIVE_EXTENSIONS",
")",
":",
"filename",
",",
"ext",
"=",
"splitext",
"(",
"filename",
")",
"if",
"is_git_sha",
"(",
"filename",
")",
":",
"return",
"True",
"return",
"False"
] |
Returns whether this requirement is always unsatisfied
This would happen in cases where we can't determine the version
from the filename.
|
[
"Returns",
"whether",
"this",
"requirement",
"is",
"always",
"unsatisfied"
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L473-L490
|
erikrose/peep
|
peep.py
|
DownloadedReq._download
|
def _download(self, link):
"""Download a file, and return its name within my temp dir.
This does no verification of HTTPS certs, but our checking hashes
makes that largely unimportant. It would be nice to be able to use the
requests lib, which can verify certs, but it is guaranteed to be
available only in pip >= 1.5.
This also drops support for proxies and basic auth, though those could
be added back in.
"""
# Based on pip 1.4.1's URLOpener but with cert verification removed
def opener(is_https):
if is_https:
opener = build_opener(HTTPSHandler())
# Strip out HTTPHandler to prevent MITM spoof:
for handler in opener.handlers:
if isinstance(handler, HTTPHandler):
opener.handlers.remove(handler)
else:
opener = build_opener()
return opener
# Descended from unpack_http_url() in pip 1.4.1
def best_filename(link, response):
"""Return the most informative possible filename for a download,
ideally with a proper extension.
"""
content_type = response.info().get('content-type', '')
filename = link.filename # fallback
# Have a look at the Content-Disposition header for a better guess:
content_disposition = response.info().get('content-disposition')
if content_disposition:
type, params = cgi.parse_header(content_disposition)
# We use ``or`` here because we don't want to use an "empty" value
# from the filename param:
filename = params.get('filename') or filename
ext = splitext(filename)[1]
if not ext:
ext = mimetypes.guess_extension(content_type)
if ext:
filename += ext
if not ext and link.url != response.geturl():
ext = splitext(response.geturl())[1]
if ext:
filename += ext
return filename
# Descended from _download_url() in pip 1.4.1
def pipe_to_file(response, path, size=0):
"""Pull the data off an HTTP response, shove it in a new file, and
show progress.
:arg response: A file-like object to read from
:arg path: The path of the new file
:arg size: The expected size, in bytes, of the download. 0 for
unknown or to suppress progress indication (as for cached
downloads)
"""
def response_chunks(chunk_size):
while True:
chunk = response.read(chunk_size)
if not chunk:
break
yield chunk
print('Downloading %s%s...' % (
self._req.req,
(' (%sK)' % (size / 1000)) if size > 1000 else ''))
progress_indicator = (DownloadProgressBar(max=size).iter if size
else DownloadProgressSpinner().iter)
with open(path, 'wb') as file:
for chunk in progress_indicator(response_chunks(4096), 4096):
file.write(chunk)
url = link.url.split('#', 1)[0]
try:
response = opener(urlparse(url).scheme != 'http').open(url)
except (HTTPError, IOError) as exc:
raise DownloadError(link, exc)
filename = best_filename(link, response)
try:
size = int(response.headers['content-length'])
except (ValueError, KeyError, TypeError):
size = 0
pipe_to_file(response, join(self._temp_path, filename), size=size)
return filename
|
python
|
def _download(self, link):
"""Download a file, and return its name within my temp dir.
This does no verification of HTTPS certs, but our checking hashes
makes that largely unimportant. It would be nice to be able to use the
requests lib, which can verify certs, but it is guaranteed to be
available only in pip >= 1.5.
This also drops support for proxies and basic auth, though those could
be added back in.
"""
# Based on pip 1.4.1's URLOpener but with cert verification removed
def opener(is_https):
if is_https:
opener = build_opener(HTTPSHandler())
# Strip out HTTPHandler to prevent MITM spoof:
for handler in opener.handlers:
if isinstance(handler, HTTPHandler):
opener.handlers.remove(handler)
else:
opener = build_opener()
return opener
# Descended from unpack_http_url() in pip 1.4.1
def best_filename(link, response):
"""Return the most informative possible filename for a download,
ideally with a proper extension.
"""
content_type = response.info().get('content-type', '')
filename = link.filename # fallback
# Have a look at the Content-Disposition header for a better guess:
content_disposition = response.info().get('content-disposition')
if content_disposition:
type, params = cgi.parse_header(content_disposition)
# We use ``or`` here because we don't want to use an "empty" value
# from the filename param:
filename = params.get('filename') or filename
ext = splitext(filename)[1]
if not ext:
ext = mimetypes.guess_extension(content_type)
if ext:
filename += ext
if not ext and link.url != response.geturl():
ext = splitext(response.geturl())[1]
if ext:
filename += ext
return filename
# Descended from _download_url() in pip 1.4.1
def pipe_to_file(response, path, size=0):
"""Pull the data off an HTTP response, shove it in a new file, and
show progress.
:arg response: A file-like object to read from
:arg path: The path of the new file
:arg size: The expected size, in bytes, of the download. 0 for
unknown or to suppress progress indication (as for cached
downloads)
"""
def response_chunks(chunk_size):
while True:
chunk = response.read(chunk_size)
if not chunk:
break
yield chunk
print('Downloading %s%s...' % (
self._req.req,
(' (%sK)' % (size / 1000)) if size > 1000 else ''))
progress_indicator = (DownloadProgressBar(max=size).iter if size
else DownloadProgressSpinner().iter)
with open(path, 'wb') as file:
for chunk in progress_indicator(response_chunks(4096), 4096):
file.write(chunk)
url = link.url.split('#', 1)[0]
try:
response = opener(urlparse(url).scheme != 'http').open(url)
except (HTTPError, IOError) as exc:
raise DownloadError(link, exc)
filename = best_filename(link, response)
try:
size = int(response.headers['content-length'])
except (ValueError, KeyError, TypeError):
size = 0
pipe_to_file(response, join(self._temp_path, filename), size=size)
return filename
|
[
"def",
"_download",
"(",
"self",
",",
"link",
")",
":",
"# Based on pip 1.4.1's URLOpener but with cert verification removed",
"def",
"opener",
"(",
"is_https",
")",
":",
"if",
"is_https",
":",
"opener",
"=",
"build_opener",
"(",
"HTTPSHandler",
"(",
")",
")",
"# Strip out HTTPHandler to prevent MITM spoof:",
"for",
"handler",
"in",
"opener",
".",
"handlers",
":",
"if",
"isinstance",
"(",
"handler",
",",
"HTTPHandler",
")",
":",
"opener",
".",
"handlers",
".",
"remove",
"(",
"handler",
")",
"else",
":",
"opener",
"=",
"build_opener",
"(",
")",
"return",
"opener",
"# Descended from unpack_http_url() in pip 1.4.1",
"def",
"best_filename",
"(",
"link",
",",
"response",
")",
":",
"\"\"\"Return the most informative possible filename for a download,\n ideally with a proper extension.\n\n \"\"\"",
"content_type",
"=",
"response",
".",
"info",
"(",
")",
".",
"get",
"(",
"'content-type'",
",",
"''",
")",
"filename",
"=",
"link",
".",
"filename",
"# fallback",
"# Have a look at the Content-Disposition header for a better guess:",
"content_disposition",
"=",
"response",
".",
"info",
"(",
")",
".",
"get",
"(",
"'content-disposition'",
")",
"if",
"content_disposition",
":",
"type",
",",
"params",
"=",
"cgi",
".",
"parse_header",
"(",
"content_disposition",
")",
"# We use ``or`` here because we don't want to use an \"empty\" value",
"# from the filename param:",
"filename",
"=",
"params",
".",
"get",
"(",
"'filename'",
")",
"or",
"filename",
"ext",
"=",
"splitext",
"(",
"filename",
")",
"[",
"1",
"]",
"if",
"not",
"ext",
":",
"ext",
"=",
"mimetypes",
".",
"guess_extension",
"(",
"content_type",
")",
"if",
"ext",
":",
"filename",
"+=",
"ext",
"if",
"not",
"ext",
"and",
"link",
".",
"url",
"!=",
"response",
".",
"geturl",
"(",
")",
":",
"ext",
"=",
"splitext",
"(",
"response",
".",
"geturl",
"(",
")",
")",
"[",
"1",
"]",
"if",
"ext",
":",
"filename",
"+=",
"ext",
"return",
"filename",
"# Descended from _download_url() in pip 1.4.1",
"def",
"pipe_to_file",
"(",
"response",
",",
"path",
",",
"size",
"=",
"0",
")",
":",
"\"\"\"Pull the data off an HTTP response, shove it in a new file, and\n show progress.\n\n :arg response: A file-like object to read from\n :arg path: The path of the new file\n :arg size: The expected size, in bytes, of the download. 0 for\n unknown or to suppress progress indication (as for cached\n downloads)\n\n \"\"\"",
"def",
"response_chunks",
"(",
"chunk_size",
")",
":",
"while",
"True",
":",
"chunk",
"=",
"response",
".",
"read",
"(",
"chunk_size",
")",
"if",
"not",
"chunk",
":",
"break",
"yield",
"chunk",
"print",
"(",
"'Downloading %s%s...'",
"%",
"(",
"self",
".",
"_req",
".",
"req",
",",
"(",
"' (%sK)'",
"%",
"(",
"size",
"/",
"1000",
")",
")",
"if",
"size",
">",
"1000",
"else",
"''",
")",
")",
"progress_indicator",
"=",
"(",
"DownloadProgressBar",
"(",
"max",
"=",
"size",
")",
".",
"iter",
"if",
"size",
"else",
"DownloadProgressSpinner",
"(",
")",
".",
"iter",
")",
"with",
"open",
"(",
"path",
",",
"'wb'",
")",
"as",
"file",
":",
"for",
"chunk",
"in",
"progress_indicator",
"(",
"response_chunks",
"(",
"4096",
")",
",",
"4096",
")",
":",
"file",
".",
"write",
"(",
"chunk",
")",
"url",
"=",
"link",
".",
"url",
".",
"split",
"(",
"'#'",
",",
"1",
")",
"[",
"0",
"]",
"try",
":",
"response",
"=",
"opener",
"(",
"urlparse",
"(",
"url",
")",
".",
"scheme",
"!=",
"'http'",
")",
".",
"open",
"(",
"url",
")",
"except",
"(",
"HTTPError",
",",
"IOError",
")",
"as",
"exc",
":",
"raise",
"DownloadError",
"(",
"link",
",",
"exc",
")",
"filename",
"=",
"best_filename",
"(",
"link",
",",
"response",
")",
"try",
":",
"size",
"=",
"int",
"(",
"response",
".",
"headers",
"[",
"'content-length'",
"]",
")",
"except",
"(",
"ValueError",
",",
"KeyError",
",",
"TypeError",
")",
":",
"size",
"=",
"0",
"pipe_to_file",
"(",
"response",
",",
"join",
"(",
"self",
".",
"_temp_path",
",",
"filename",
")",
",",
"size",
"=",
"size",
")",
"return",
"filename"
] |
Download a file, and return its name within my temp dir.
This does no verification of HTTPS certs, but our checking hashes
makes that largely unimportant. It would be nice to be able to use the
requests lib, which can verify certs, but it is guaranteed to be
available only in pip >= 1.5.
This also drops support for proxies and basic auth, though those could
be added back in.
|
[
"Download",
"a",
"file",
"and",
"return",
"its",
"name",
"within",
"my",
"temp",
"dir",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L497-L586
|
erikrose/peep
|
peep.py
|
DownloadedReq._downloaded_filename
|
def _downloaded_filename(self):
"""Download the package's archive if necessary, and return its
filename.
--no-deps is implied, as we have reimplemented the bits that would
ordinarily do dependency resolution.
"""
# Peep doesn't support requirements that don't come down as a single
# file, because it can't hash them. Thus, it doesn't support editable
# requirements, because pip itself doesn't support editable
# requirements except for "local projects or a VCS url". Nor does it
# support VCS requirements yet, because we haven't yet come up with a
# portable, deterministic way to hash them. In summary, all we support
# is == requirements and tarballs/zips/etc.
# TODO: Stop on reqs that are editable or aren't ==.
# If the requirement isn't already specified as a URL, get a URL
# from an index:
link = self._link() or self._finder.find_requirement(self._req, upgrade=False)
if link:
lower_scheme = link.scheme.lower() # pip lower()s it for some reason.
if lower_scheme == 'http' or lower_scheme == 'https':
file_path = self._download(link)
return basename(file_path)
elif lower_scheme == 'file':
# The following is inspired by pip's unpack_file_url():
link_path = url_to_path(link.url_without_fragment)
if isdir(link_path):
raise UnsupportedRequirementError(
"%s: %s is a directory. So that it can compute "
"a hash, peep supports only filesystem paths which "
"point to files" %
(self._req, link.url_without_fragment))
else:
copy(link_path, self._temp_path)
return basename(link_path)
else:
raise UnsupportedRequirementError(
"%s: The download link, %s, would not result in a file "
"that can be hashed. Peep supports only == requirements, "
"file:// URLs pointing to files (not folders), and "
"http:// and https:// URLs pointing to tarballs, zips, "
"etc." % (self._req, link.url))
else:
raise UnsupportedRequirementError(
"%s: couldn't determine where to download this requirement from."
% (self._req,))
|
python
|
def _downloaded_filename(self):
"""Download the package's archive if necessary, and return its
filename.
--no-deps is implied, as we have reimplemented the bits that would
ordinarily do dependency resolution.
"""
# Peep doesn't support requirements that don't come down as a single
# file, because it can't hash them. Thus, it doesn't support editable
# requirements, because pip itself doesn't support editable
# requirements except for "local projects or a VCS url". Nor does it
# support VCS requirements yet, because we haven't yet come up with a
# portable, deterministic way to hash them. In summary, all we support
# is == requirements and tarballs/zips/etc.
# TODO: Stop on reqs that are editable or aren't ==.
# If the requirement isn't already specified as a URL, get a URL
# from an index:
link = self._link() or self._finder.find_requirement(self._req, upgrade=False)
if link:
lower_scheme = link.scheme.lower() # pip lower()s it for some reason.
if lower_scheme == 'http' or lower_scheme == 'https':
file_path = self._download(link)
return basename(file_path)
elif lower_scheme == 'file':
# The following is inspired by pip's unpack_file_url():
link_path = url_to_path(link.url_without_fragment)
if isdir(link_path):
raise UnsupportedRequirementError(
"%s: %s is a directory. So that it can compute "
"a hash, peep supports only filesystem paths which "
"point to files" %
(self._req, link.url_without_fragment))
else:
copy(link_path, self._temp_path)
return basename(link_path)
else:
raise UnsupportedRequirementError(
"%s: The download link, %s, would not result in a file "
"that can be hashed. Peep supports only == requirements, "
"file:// URLs pointing to files (not folders), and "
"http:// and https:// URLs pointing to tarballs, zips, "
"etc." % (self._req, link.url))
else:
raise UnsupportedRequirementError(
"%s: couldn't determine where to download this requirement from."
% (self._req,))
|
[
"def",
"_downloaded_filename",
"(",
"self",
")",
":",
"# Peep doesn't support requirements that don't come down as a single",
"# file, because it can't hash them. Thus, it doesn't support editable",
"# requirements, because pip itself doesn't support editable",
"# requirements except for \"local projects or a VCS url\". Nor does it",
"# support VCS requirements yet, because we haven't yet come up with a",
"# portable, deterministic way to hash them. In summary, all we support",
"# is == requirements and tarballs/zips/etc.",
"# TODO: Stop on reqs that are editable or aren't ==.",
"# If the requirement isn't already specified as a URL, get a URL",
"# from an index:",
"link",
"=",
"self",
".",
"_link",
"(",
")",
"or",
"self",
".",
"_finder",
".",
"find_requirement",
"(",
"self",
".",
"_req",
",",
"upgrade",
"=",
"False",
")",
"if",
"link",
":",
"lower_scheme",
"=",
"link",
".",
"scheme",
".",
"lower",
"(",
")",
"# pip lower()s it for some reason.",
"if",
"lower_scheme",
"==",
"'http'",
"or",
"lower_scheme",
"==",
"'https'",
":",
"file_path",
"=",
"self",
".",
"_download",
"(",
"link",
")",
"return",
"basename",
"(",
"file_path",
")",
"elif",
"lower_scheme",
"==",
"'file'",
":",
"# The following is inspired by pip's unpack_file_url():",
"link_path",
"=",
"url_to_path",
"(",
"link",
".",
"url_without_fragment",
")",
"if",
"isdir",
"(",
"link_path",
")",
":",
"raise",
"UnsupportedRequirementError",
"(",
"\"%s: %s is a directory. So that it can compute \"",
"\"a hash, peep supports only filesystem paths which \"",
"\"point to files\"",
"%",
"(",
"self",
".",
"_req",
",",
"link",
".",
"url_without_fragment",
")",
")",
"else",
":",
"copy",
"(",
"link_path",
",",
"self",
".",
"_temp_path",
")",
"return",
"basename",
"(",
"link_path",
")",
"else",
":",
"raise",
"UnsupportedRequirementError",
"(",
"\"%s: The download link, %s, would not result in a file \"",
"\"that can be hashed. Peep supports only == requirements, \"",
"\"file:// URLs pointing to files (not folders), and \"",
"\"http:// and https:// URLs pointing to tarballs, zips, \"",
"\"etc.\"",
"%",
"(",
"self",
".",
"_req",
",",
"link",
".",
"url",
")",
")",
"else",
":",
"raise",
"UnsupportedRequirementError",
"(",
"\"%s: couldn't determine where to download this requirement from.\"",
"%",
"(",
"self",
".",
"_req",
",",
")",
")"
] |
Download the package's archive if necessary, and return its
filename.
--no-deps is implied, as we have reimplemented the bits that would
ordinarily do dependency resolution.
|
[
"Download",
"the",
"package",
"s",
"archive",
"if",
"necessary",
"and",
"return",
"its",
"filename",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L590-L639
|
erikrose/peep
|
peep.py
|
DownloadedReq.install
|
def install(self):
"""Install the package I represent, without dependencies.
Obey typical pip-install options passed in on the command line.
"""
other_args = list(requirement_args(self._argv, want_other=True))
archive_path = join(self._temp_path, self._downloaded_filename())
# -U so it installs whether pip deems the requirement "satisfied" or
# not. This is necessary for GitHub-sourced zips, which change without
# their version numbers changing.
run_pip(['install'] + other_args + ['--no-deps', '-U', archive_path])
|
python
|
def install(self):
"""Install the package I represent, without dependencies.
Obey typical pip-install options passed in on the command line.
"""
other_args = list(requirement_args(self._argv, want_other=True))
archive_path = join(self._temp_path, self._downloaded_filename())
# -U so it installs whether pip deems the requirement "satisfied" or
# not. This is necessary for GitHub-sourced zips, which change without
# their version numbers changing.
run_pip(['install'] + other_args + ['--no-deps', '-U', archive_path])
|
[
"def",
"install",
"(",
"self",
")",
":",
"other_args",
"=",
"list",
"(",
"requirement_args",
"(",
"self",
".",
"_argv",
",",
"want_other",
"=",
"True",
")",
")",
"archive_path",
"=",
"join",
"(",
"self",
".",
"_temp_path",
",",
"self",
".",
"_downloaded_filename",
"(",
")",
")",
"# -U so it installs whether pip deems the requirement \"satisfied\" or",
"# not. This is necessary for GitHub-sourced zips, which change without",
"# their version numbers changing.",
"run_pip",
"(",
"[",
"'install'",
"]",
"+",
"other_args",
"+",
"[",
"'--no-deps'",
",",
"'-U'",
",",
"archive_path",
"]",
")"
] |
Install the package I represent, without dependencies.
Obey typical pip-install options passed in on the command line.
|
[
"Install",
"the",
"package",
"I",
"represent",
"without",
"dependencies",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L641-L652
|
erikrose/peep
|
peep.py
|
DownloadedReq._project_name
|
def _project_name(self):
"""Return the inner Requirement's "unsafe name".
Raise ValueError if there is no name.
"""
name = getattr(self._req.req, 'project_name', '')
if name:
return name
name = getattr(self._req.req, 'name', '')
if name:
return safe_name(name)
raise ValueError('Requirement has no project_name.')
|
python
|
def _project_name(self):
"""Return the inner Requirement's "unsafe name".
Raise ValueError if there is no name.
"""
name = getattr(self._req.req, 'project_name', '')
if name:
return name
name = getattr(self._req.req, 'name', '')
if name:
return safe_name(name)
raise ValueError('Requirement has no project_name.')
|
[
"def",
"_project_name",
"(",
"self",
")",
":",
"name",
"=",
"getattr",
"(",
"self",
".",
"_req",
".",
"req",
",",
"'project_name'",
",",
"''",
")",
"if",
"name",
":",
"return",
"name",
"name",
"=",
"getattr",
"(",
"self",
".",
"_req",
".",
"req",
",",
"'name'",
",",
"''",
")",
"if",
"name",
":",
"return",
"safe_name",
"(",
"name",
")",
"raise",
"ValueError",
"(",
"'Requirement has no project_name.'",
")"
] |
Return the inner Requirement's "unsafe name".
Raise ValueError if there is no name.
|
[
"Return",
"the",
"inner",
"Requirement",
"s",
"unsafe",
"name",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L659-L671
|
erikrose/peep
|
peep.py
|
DownloadedReq._class
|
def _class(self):
"""Return the class I should be, spanning a continuum of goodness."""
try:
self._project_name()
except ValueError:
return MalformedReq
if self._is_satisfied():
return SatisfiedReq
if not self._expected_hashes():
return MissingReq
if self._actual_hash() not in self._expected_hashes():
return MismatchedReq
return InstallableReq
|
python
|
def _class(self):
"""Return the class I should be, spanning a continuum of goodness."""
try:
self._project_name()
except ValueError:
return MalformedReq
if self._is_satisfied():
return SatisfiedReq
if not self._expected_hashes():
return MissingReq
if self._actual_hash() not in self._expected_hashes():
return MismatchedReq
return InstallableReq
|
[
"def",
"_class",
"(",
"self",
")",
":",
"try",
":",
"self",
".",
"_project_name",
"(",
")",
"except",
"ValueError",
":",
"return",
"MalformedReq",
"if",
"self",
".",
"_is_satisfied",
"(",
")",
":",
"return",
"SatisfiedReq",
"if",
"not",
"self",
".",
"_expected_hashes",
"(",
")",
":",
"return",
"MissingReq",
"if",
"self",
".",
"_actual_hash",
"(",
")",
"not",
"in",
"self",
".",
"_expected_hashes",
"(",
")",
":",
"return",
"MismatchedReq",
"return",
"InstallableReq"
] |
Return the class I should be, spanning a continuum of goodness.
|
[
"Return",
"the",
"class",
"I",
"should",
"be",
"spanning",
"a",
"continuum",
"of",
"goodness",
"."
] |
train
|
https://github.com/erikrose/peep/blob/c16f08c7f61e2f2afecb7cd1c93752bdd96c4968/peep.py#L694-L706
|
toloco/pyoanda
|
pyoanda/order.py
|
Order.check
|
def check(self):
"""
Logic extracted from:
http://developer.oanda.com/rest-live/orders/#createNewOrder
"""
for k in iter(self.__dict__.keys()):
if k not in self.__allowed:
raise TypeError("Parameter not allowed {}".format(k))
for k in self.__requiered:
if k not in self.__dict__:
raise TypeError("Requiered parameter not found {}".format(k))
if not isinstance(self.units, (int, float)):
msg = "Unit must be either int or float, '{}'' found".format(
type(self.units))
raise TypeError(msg)
if self.side not in self.__side:
msg = "Side must be in {1}, '{0}' found".format(
self.side, self.__side)
raise TypeError(msg)
if self.type not in self.__type:
msg = "Type must be in {1}, '{0}' found".format(
self.type, self.__type)
raise TypeError(msg)
if not self.type == "market" and (
not hasattr(self, "expiry") or not hasattr(self, "price")):
msg = "As type is {}, expiry and price must be provided".format(
self.type)
raise TypeError(msg)
if hasattr(self, "expiry") and not isinstance(self.expiry, datetime):
msg = "Expiry must be {1}, '{0}' found".format(
type(self.expiry), datetime)
raise TypeError(msg)
if hasattr(self, "price"):
try:
Decimal(self.price)
except InvalidOperation:
msg = "Expiry must be int or float, '{0}' found".format(
type(self.price))
raise TypeError(msg)
return True
|
python
|
def check(self):
"""
Logic extracted from:
http://developer.oanda.com/rest-live/orders/#createNewOrder
"""
for k in iter(self.__dict__.keys()):
if k not in self.__allowed:
raise TypeError("Parameter not allowed {}".format(k))
for k in self.__requiered:
if k not in self.__dict__:
raise TypeError("Requiered parameter not found {}".format(k))
if not isinstance(self.units, (int, float)):
msg = "Unit must be either int or float, '{}'' found".format(
type(self.units))
raise TypeError(msg)
if self.side not in self.__side:
msg = "Side must be in {1}, '{0}' found".format(
self.side, self.__side)
raise TypeError(msg)
if self.type not in self.__type:
msg = "Type must be in {1}, '{0}' found".format(
self.type, self.__type)
raise TypeError(msg)
if not self.type == "market" and (
not hasattr(self, "expiry") or not hasattr(self, "price")):
msg = "As type is {}, expiry and price must be provided".format(
self.type)
raise TypeError(msg)
if hasattr(self, "expiry") and not isinstance(self.expiry, datetime):
msg = "Expiry must be {1}, '{0}' found".format(
type(self.expiry), datetime)
raise TypeError(msg)
if hasattr(self, "price"):
try:
Decimal(self.price)
except InvalidOperation:
msg = "Expiry must be int or float, '{0}' found".format(
type(self.price))
raise TypeError(msg)
return True
|
[
"def",
"check",
"(",
"self",
")",
":",
"for",
"k",
"in",
"iter",
"(",
"self",
".",
"__dict__",
".",
"keys",
"(",
")",
")",
":",
"if",
"k",
"not",
"in",
"self",
".",
"__allowed",
":",
"raise",
"TypeError",
"(",
"\"Parameter not allowed {}\"",
".",
"format",
"(",
"k",
")",
")",
"for",
"k",
"in",
"self",
".",
"__requiered",
":",
"if",
"k",
"not",
"in",
"self",
".",
"__dict__",
":",
"raise",
"TypeError",
"(",
"\"Requiered parameter not found {}\"",
".",
"format",
"(",
"k",
")",
")",
"if",
"not",
"isinstance",
"(",
"self",
".",
"units",
",",
"(",
"int",
",",
"float",
")",
")",
":",
"msg",
"=",
"\"Unit must be either int or float, '{}'' found\"",
".",
"format",
"(",
"type",
"(",
"self",
".",
"units",
")",
")",
"raise",
"TypeError",
"(",
"msg",
")",
"if",
"self",
".",
"side",
"not",
"in",
"self",
".",
"__side",
":",
"msg",
"=",
"\"Side must be in {1}, '{0}' found\"",
".",
"format",
"(",
"self",
".",
"side",
",",
"self",
".",
"__side",
")",
"raise",
"TypeError",
"(",
"msg",
")",
"if",
"self",
".",
"type",
"not",
"in",
"self",
".",
"__type",
":",
"msg",
"=",
"\"Type must be in {1}, '{0}' found\"",
".",
"format",
"(",
"self",
".",
"type",
",",
"self",
".",
"__type",
")",
"raise",
"TypeError",
"(",
"msg",
")",
"if",
"not",
"self",
".",
"type",
"==",
"\"market\"",
"and",
"(",
"not",
"hasattr",
"(",
"self",
",",
"\"expiry\"",
")",
"or",
"not",
"hasattr",
"(",
"self",
",",
"\"price\"",
")",
")",
":",
"msg",
"=",
"\"As type is {}, expiry and price must be provided\"",
".",
"format",
"(",
"self",
".",
"type",
")",
"raise",
"TypeError",
"(",
"msg",
")",
"if",
"hasattr",
"(",
"self",
",",
"\"expiry\"",
")",
"and",
"not",
"isinstance",
"(",
"self",
".",
"expiry",
",",
"datetime",
")",
":",
"msg",
"=",
"\"Expiry must be {1}, '{0}' found\"",
".",
"format",
"(",
"type",
"(",
"self",
".",
"expiry",
")",
",",
"datetime",
")",
"raise",
"TypeError",
"(",
"msg",
")",
"if",
"hasattr",
"(",
"self",
",",
"\"price\"",
")",
":",
"try",
":",
"Decimal",
"(",
"self",
".",
"price",
")",
"except",
"InvalidOperation",
":",
"msg",
"=",
"\"Expiry must be int or float, '{0}' found\"",
".",
"format",
"(",
"type",
"(",
"self",
".",
"price",
")",
")",
"raise",
"TypeError",
"(",
"msg",
")",
"return",
"True"
] |
Logic extracted from:
http://developer.oanda.com/rest-live/orders/#createNewOrder
|
[
"Logic",
"extracted",
"from",
":",
"http",
":",
"//",
"developer",
".",
"oanda",
".",
"com",
"/",
"rest",
"-",
"live",
"/",
"orders",
"/",
"#createNewOrder"
] |
train
|
https://github.com/toloco/pyoanda/blob/26b3f28a89d07c5c20d2a645884505387f1daae8/pyoanda/order.py#L21-L67
|
ddorn/GUI
|
GUI/gui_examples/login.py
|
gui
|
def gui():
"""Main function"""
global SCREEN_SIZE
# #######
# setup all objects
# #######
os.environ['SDL_VIDEO_CENTERED'] = '1'
screen = new_widow()
pygame.display.set_caption('Client swag')
pygame.event.set_allowed([QUIT, KEYDOWN, MOUSEBUTTONDOWN])
clock = pygame.time.Clock()
# fps = FPSIndicator(clock)
bound = Rectangle((0, 0), SCREEN_SIZE, BLUE, Rectangle.BORDER)
login = InLineTextBox((5, 1), 200, MIDNIGHT_BLUE, anchor=TOPLEFT, default_text='Login: ')
passw = InLinePassBox(login.topright + Sep(5, 0), 200, MIDNIGHT_BLUE, anchor=TOPLEFT, default_text='Password: ')
def sup():
print('Signed up !')
print('login:', login.text)
print('pass:', passw.text)
def sin():
print('Signed in !')
print('login:', login.text)
print('pass:', passw.text)
style = Button.NO_ROUNDING | Button.NO_MOVE | Button.NO_SHADOW
sign_up = Button(sup, passw.topright + Sep(5, 0), (100, passw.height), 'Sign Up', YELLOW, anchor=TOPLEFT, flags=style)
sign_in = Button(sin, sign_up.topright, (100, passw.height), 'Sign In', GREEN, anchor=TOPLEFT, flags=style)
focus = FocusSelector(login, passw, sign_up, sign_in)
focus.select(0)
while True:
# #######
# Input loop
# #######
mouse = pygame.mouse.get_pos()
for e in pygame.event.get():
if e.type == QUIT:
return 0 # quit
elif e.type == KEYDOWN:
# intercept special inputs
if e.key == K_ESCAPE:
return 0 # quit
elif e.key == K_F4 and e.mod & KMOD_ALT:
return 0 # quit
elif e.key == K_TAB:
if e.mod & KMOD_SHIFT:
focus.prev()
else:
focus.next()
elif e.key == K_RETURN:
if focus.selected() in (sign_up, sign_in):
print(focus.selected())
focus.selected().click(40)
else:
focus.next()
else:
# or give them to the selected box
focus.selected().update(e)
elif e.type == VIDEORESIZE:
SCREEN_SIZE = e.size
screen = new_widow()
elif e.type == MOUSEBUTTONDOWN:
if mouse in login:
focus.select(login)
elif mouse in passw:
focus.select(passw)
elif mouse in sign_up:
sign_up.click()
elif mouse in sign_in:
sign_in.click()
elif e.type == MOUSEBUTTONUP:
sign_in.release()
sign_up.release()
# #######
# Draw all
# #######
screen.fill(WHITE)
# fps.render(screen)
bound.render(screen)
login.render(screen)
passw.render(screen)
line(screen, login.topright + Sep(2, 0), login.bottomright + Sep(2, 0), BLUE)
sign_up.render(screen)
sign_in.render(screen)
pygame.display.update()
clock.tick(FPS)
|
python
|
def gui():
"""Main function"""
global SCREEN_SIZE
# #######
# setup all objects
# #######
os.environ['SDL_VIDEO_CENTERED'] = '1'
screen = new_widow()
pygame.display.set_caption('Client swag')
pygame.event.set_allowed([QUIT, KEYDOWN, MOUSEBUTTONDOWN])
clock = pygame.time.Clock()
# fps = FPSIndicator(clock)
bound = Rectangle((0, 0), SCREEN_SIZE, BLUE, Rectangle.BORDER)
login = InLineTextBox((5, 1), 200, MIDNIGHT_BLUE, anchor=TOPLEFT, default_text='Login: ')
passw = InLinePassBox(login.topright + Sep(5, 0), 200, MIDNIGHT_BLUE, anchor=TOPLEFT, default_text='Password: ')
def sup():
print('Signed up !')
print('login:', login.text)
print('pass:', passw.text)
def sin():
print('Signed in !')
print('login:', login.text)
print('pass:', passw.text)
style = Button.NO_ROUNDING | Button.NO_MOVE | Button.NO_SHADOW
sign_up = Button(sup, passw.topright + Sep(5, 0), (100, passw.height), 'Sign Up', YELLOW, anchor=TOPLEFT, flags=style)
sign_in = Button(sin, sign_up.topright, (100, passw.height), 'Sign In', GREEN, anchor=TOPLEFT, flags=style)
focus = FocusSelector(login, passw, sign_up, sign_in)
focus.select(0)
while True:
# #######
# Input loop
# #######
mouse = pygame.mouse.get_pos()
for e in pygame.event.get():
if e.type == QUIT:
return 0 # quit
elif e.type == KEYDOWN:
# intercept special inputs
if e.key == K_ESCAPE:
return 0 # quit
elif e.key == K_F4 and e.mod & KMOD_ALT:
return 0 # quit
elif e.key == K_TAB:
if e.mod & KMOD_SHIFT:
focus.prev()
else:
focus.next()
elif e.key == K_RETURN:
if focus.selected() in (sign_up, sign_in):
print(focus.selected())
focus.selected().click(40)
else:
focus.next()
else:
# or give them to the selected box
focus.selected().update(e)
elif e.type == VIDEORESIZE:
SCREEN_SIZE = e.size
screen = new_widow()
elif e.type == MOUSEBUTTONDOWN:
if mouse in login:
focus.select(login)
elif mouse in passw:
focus.select(passw)
elif mouse in sign_up:
sign_up.click()
elif mouse in sign_in:
sign_in.click()
elif e.type == MOUSEBUTTONUP:
sign_in.release()
sign_up.release()
# #######
# Draw all
# #######
screen.fill(WHITE)
# fps.render(screen)
bound.render(screen)
login.render(screen)
passw.render(screen)
line(screen, login.topright + Sep(2, 0), login.bottomright + Sep(2, 0), BLUE)
sign_up.render(screen)
sign_in.render(screen)
pygame.display.update()
clock.tick(FPS)
|
[
"def",
"gui",
"(",
")",
":",
"global",
"SCREEN_SIZE",
"# #######",
"# setup all objects",
"# #######",
"os",
".",
"environ",
"[",
"'SDL_VIDEO_CENTERED'",
"]",
"=",
"'1'",
"screen",
"=",
"new_widow",
"(",
")",
"pygame",
".",
"display",
".",
"set_caption",
"(",
"'Client swag'",
")",
"pygame",
".",
"event",
".",
"set_allowed",
"(",
"[",
"QUIT",
",",
"KEYDOWN",
",",
"MOUSEBUTTONDOWN",
"]",
")",
"clock",
"=",
"pygame",
".",
"time",
".",
"Clock",
"(",
")",
"# fps = FPSIndicator(clock)",
"bound",
"=",
"Rectangle",
"(",
"(",
"0",
",",
"0",
")",
",",
"SCREEN_SIZE",
",",
"BLUE",
",",
"Rectangle",
".",
"BORDER",
")",
"login",
"=",
"InLineTextBox",
"(",
"(",
"5",
",",
"1",
")",
",",
"200",
",",
"MIDNIGHT_BLUE",
",",
"anchor",
"=",
"TOPLEFT",
",",
"default_text",
"=",
"'Login: '",
")",
"passw",
"=",
"InLinePassBox",
"(",
"login",
".",
"topright",
"+",
"Sep",
"(",
"5",
",",
"0",
")",
",",
"200",
",",
"MIDNIGHT_BLUE",
",",
"anchor",
"=",
"TOPLEFT",
",",
"default_text",
"=",
"'Password: '",
")",
"def",
"sup",
"(",
")",
":",
"print",
"(",
"'Signed up !'",
")",
"print",
"(",
"'login:'",
",",
"login",
".",
"text",
")",
"print",
"(",
"'pass:'",
",",
"passw",
".",
"text",
")",
"def",
"sin",
"(",
")",
":",
"print",
"(",
"'Signed in !'",
")",
"print",
"(",
"'login:'",
",",
"login",
".",
"text",
")",
"print",
"(",
"'pass:'",
",",
"passw",
".",
"text",
")",
"style",
"=",
"Button",
".",
"NO_ROUNDING",
"|",
"Button",
".",
"NO_MOVE",
"|",
"Button",
".",
"NO_SHADOW",
"sign_up",
"=",
"Button",
"(",
"sup",
",",
"passw",
".",
"topright",
"+",
"Sep",
"(",
"5",
",",
"0",
")",
",",
"(",
"100",
",",
"passw",
".",
"height",
")",
",",
"'Sign Up'",
",",
"YELLOW",
",",
"anchor",
"=",
"TOPLEFT",
",",
"flags",
"=",
"style",
")",
"sign_in",
"=",
"Button",
"(",
"sin",
",",
"sign_up",
".",
"topright",
",",
"(",
"100",
",",
"passw",
".",
"height",
")",
",",
"'Sign In'",
",",
"GREEN",
",",
"anchor",
"=",
"TOPLEFT",
",",
"flags",
"=",
"style",
")",
"focus",
"=",
"FocusSelector",
"(",
"login",
",",
"passw",
",",
"sign_up",
",",
"sign_in",
")",
"focus",
".",
"select",
"(",
"0",
")",
"while",
"True",
":",
"# #######",
"# Input loop",
"# #######",
"mouse",
"=",
"pygame",
".",
"mouse",
".",
"get_pos",
"(",
")",
"for",
"e",
"in",
"pygame",
".",
"event",
".",
"get",
"(",
")",
":",
"if",
"e",
".",
"type",
"==",
"QUIT",
":",
"return",
"0",
"# quit",
"elif",
"e",
".",
"type",
"==",
"KEYDOWN",
":",
"# intercept special inputs",
"if",
"e",
".",
"key",
"==",
"K_ESCAPE",
":",
"return",
"0",
"# quit",
"elif",
"e",
".",
"key",
"==",
"K_F4",
"and",
"e",
".",
"mod",
"&",
"KMOD_ALT",
":",
"return",
"0",
"# quit",
"elif",
"e",
".",
"key",
"==",
"K_TAB",
":",
"if",
"e",
".",
"mod",
"&",
"KMOD_SHIFT",
":",
"focus",
".",
"prev",
"(",
")",
"else",
":",
"focus",
".",
"next",
"(",
")",
"elif",
"e",
".",
"key",
"==",
"K_RETURN",
":",
"if",
"focus",
".",
"selected",
"(",
")",
"in",
"(",
"sign_up",
",",
"sign_in",
")",
":",
"print",
"(",
"focus",
".",
"selected",
"(",
")",
")",
"focus",
".",
"selected",
"(",
")",
".",
"click",
"(",
"40",
")",
"else",
":",
"focus",
".",
"next",
"(",
")",
"else",
":",
"# or give them to the selected box",
"focus",
".",
"selected",
"(",
")",
".",
"update",
"(",
"e",
")",
"elif",
"e",
".",
"type",
"==",
"VIDEORESIZE",
":",
"SCREEN_SIZE",
"=",
"e",
".",
"size",
"screen",
"=",
"new_widow",
"(",
")",
"elif",
"e",
".",
"type",
"==",
"MOUSEBUTTONDOWN",
":",
"if",
"mouse",
"in",
"login",
":",
"focus",
".",
"select",
"(",
"login",
")",
"elif",
"mouse",
"in",
"passw",
":",
"focus",
".",
"select",
"(",
"passw",
")",
"elif",
"mouse",
"in",
"sign_up",
":",
"sign_up",
".",
"click",
"(",
")",
"elif",
"mouse",
"in",
"sign_in",
":",
"sign_in",
".",
"click",
"(",
")",
"elif",
"e",
".",
"type",
"==",
"MOUSEBUTTONUP",
":",
"sign_in",
".",
"release",
"(",
")",
"sign_up",
".",
"release",
"(",
")",
"# #######",
"# Draw all",
"# #######",
"screen",
".",
"fill",
"(",
"WHITE",
")",
"# fps.render(screen)",
"bound",
".",
"render",
"(",
"screen",
")",
"login",
".",
"render",
"(",
"screen",
")",
"passw",
".",
"render",
"(",
"screen",
")",
"line",
"(",
"screen",
",",
"login",
".",
"topright",
"+",
"Sep",
"(",
"2",
",",
"0",
")",
",",
"login",
".",
"bottomright",
"+",
"Sep",
"(",
"2",
",",
"0",
")",
",",
"BLUE",
")",
"sign_up",
".",
"render",
"(",
"screen",
")",
"sign_in",
".",
"render",
"(",
"screen",
")",
"pygame",
".",
"display",
".",
"update",
"(",
")",
"clock",
".",
"tick",
"(",
"FPS",
")"
] |
Main function
|
[
"Main",
"function"
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/gui_examples/login.py#L25-L134
|
ddorn/GUI
|
GUI/gui_examples/empty_template.py
|
gui
|
def gui():
"""Main function"""
global SCREEN_SIZE
# #######
# setup all objects
# #######
os.environ['SDL_VIDEO_CENTERED'] = '1' # centers the windows
screen = new_screen()
pygame.display.set_caption('Empty project')
pygame.event.set_allowed([QUIT, KEYDOWN, MOUSEBUTTONDOWN])
clock = pygame.time.Clock()
fps = FPSIndicator(clock)
while True:
# #######
# Input loop
# #######
# mouse = pygame.mouse.get_pos()
for e in pygame.event.get():
if e.type == QUIT:
return 0
elif e.type == KEYDOWN:
if e.key == K_ESCAPE:
return 0
if e.key == K_F4 and e.mod & KMOD_ALT: # Alt+F4 --> quits
return 0
if e.type == VIDEORESIZE:
SCREEN_SIZE = e.size
screen = new_screen()
# #######
# Draw all
# #######
screen.fill(WHITE)
fps.render(screen)
pygame.display.update()
clock.tick(FPS)
|
python
|
def gui():
"""Main function"""
global SCREEN_SIZE
# #######
# setup all objects
# #######
os.environ['SDL_VIDEO_CENTERED'] = '1' # centers the windows
screen = new_screen()
pygame.display.set_caption('Empty project')
pygame.event.set_allowed([QUIT, KEYDOWN, MOUSEBUTTONDOWN])
clock = pygame.time.Clock()
fps = FPSIndicator(clock)
while True:
# #######
# Input loop
# #######
# mouse = pygame.mouse.get_pos()
for e in pygame.event.get():
if e.type == QUIT:
return 0
elif e.type == KEYDOWN:
if e.key == K_ESCAPE:
return 0
if e.key == K_F4 and e.mod & KMOD_ALT: # Alt+F4 --> quits
return 0
if e.type == VIDEORESIZE:
SCREEN_SIZE = e.size
screen = new_screen()
# #######
# Draw all
# #######
screen.fill(WHITE)
fps.render(screen)
pygame.display.update()
clock.tick(FPS)
|
[
"def",
"gui",
"(",
")",
":",
"global",
"SCREEN_SIZE",
"# #######",
"# setup all objects",
"# #######",
"os",
".",
"environ",
"[",
"'SDL_VIDEO_CENTERED'",
"]",
"=",
"'1'",
"# centers the windows",
"screen",
"=",
"new_screen",
"(",
")",
"pygame",
".",
"display",
".",
"set_caption",
"(",
"'Empty project'",
")",
"pygame",
".",
"event",
".",
"set_allowed",
"(",
"[",
"QUIT",
",",
"KEYDOWN",
",",
"MOUSEBUTTONDOWN",
"]",
")",
"clock",
"=",
"pygame",
".",
"time",
".",
"Clock",
"(",
")",
"fps",
"=",
"FPSIndicator",
"(",
"clock",
")",
"while",
"True",
":",
"# #######",
"# Input loop",
"# #######",
"# mouse = pygame.mouse.get_pos()",
"for",
"e",
"in",
"pygame",
".",
"event",
".",
"get",
"(",
")",
":",
"if",
"e",
".",
"type",
"==",
"QUIT",
":",
"return",
"0",
"elif",
"e",
".",
"type",
"==",
"KEYDOWN",
":",
"if",
"e",
".",
"key",
"==",
"K_ESCAPE",
":",
"return",
"0",
"if",
"e",
".",
"key",
"==",
"K_F4",
"and",
"e",
".",
"mod",
"&",
"KMOD_ALT",
":",
"# Alt+F4 --> quits",
"return",
"0",
"if",
"e",
".",
"type",
"==",
"VIDEORESIZE",
":",
"SCREEN_SIZE",
"=",
"e",
".",
"size",
"screen",
"=",
"new_screen",
"(",
")",
"# #######",
"# Draw all",
"# #######",
"screen",
".",
"fill",
"(",
"WHITE",
")",
"fps",
".",
"render",
"(",
"screen",
")",
"pygame",
".",
"display",
".",
"update",
"(",
")",
"clock",
".",
"tick",
"(",
"FPS",
")"
] |
Main function
|
[
"Main",
"function"
] |
train
|
https://github.com/ddorn/GUI/blob/e1fcb5286d24e0995f280d5180222e51895c368c/GUI/gui_examples/empty_template.py#L25-L72
|
toloco/pyoanda
|
pyoanda/client.py
|
Client.__get_response
|
def __get_response(self, uri, params=None, method="get", stream=False):
"""Creates a response object with the given params and option
Parameters
----------
url : string
The full URL to request.
params: dict
A list of parameters to send with the request. This
will be sent as data for methods that accept a request
body and will otherwise be sent as query parameters.
method : str
The HTTP method to use.
stream : bool
Whether to stream the response.
Returns a requests.Response object.
"""
if not hasattr(self, "session") or not self.session:
self.session = requests.Session()
if self.access_token:
self.session.headers.update(
{'Authorization': 'Bearer {}'.format(self.access_token)}
)
# Remove empty params
if params:
params = {k: v for k, v in params.items() if v is not None}
kwargs = {
"url": uri,
"verify": True,
"stream": stream
}
kwargs["params" if method == "get" else "data"] = params
return getattr(self.session, method)(**kwargs)
|
python
|
def __get_response(self, uri, params=None, method="get", stream=False):
"""Creates a response object with the given params and option
Parameters
----------
url : string
The full URL to request.
params: dict
A list of parameters to send with the request. This
will be sent as data for methods that accept a request
body and will otherwise be sent as query parameters.
method : str
The HTTP method to use.
stream : bool
Whether to stream the response.
Returns a requests.Response object.
"""
if not hasattr(self, "session") or not self.session:
self.session = requests.Session()
if self.access_token:
self.session.headers.update(
{'Authorization': 'Bearer {}'.format(self.access_token)}
)
# Remove empty params
if params:
params = {k: v for k, v in params.items() if v is not None}
kwargs = {
"url": uri,
"verify": True,
"stream": stream
}
kwargs["params" if method == "get" else "data"] = params
return getattr(self.session, method)(**kwargs)
|
[
"def",
"__get_response",
"(",
"self",
",",
"uri",
",",
"params",
"=",
"None",
",",
"method",
"=",
"\"get\"",
",",
"stream",
"=",
"False",
")",
":",
"if",
"not",
"hasattr",
"(",
"self",
",",
"\"session\"",
")",
"or",
"not",
"self",
".",
"session",
":",
"self",
".",
"session",
"=",
"requests",
".",
"Session",
"(",
")",
"if",
"self",
".",
"access_token",
":",
"self",
".",
"session",
".",
"headers",
".",
"update",
"(",
"{",
"'Authorization'",
":",
"'Bearer {}'",
".",
"format",
"(",
"self",
".",
"access_token",
")",
"}",
")",
"# Remove empty params",
"if",
"params",
":",
"params",
"=",
"{",
"k",
":",
"v",
"for",
"k",
",",
"v",
"in",
"params",
".",
"items",
"(",
")",
"if",
"v",
"is",
"not",
"None",
"}",
"kwargs",
"=",
"{",
"\"url\"",
":",
"uri",
",",
"\"verify\"",
":",
"True",
",",
"\"stream\"",
":",
"stream",
"}",
"kwargs",
"[",
"\"params\"",
"if",
"method",
"==",
"\"get\"",
"else",
"\"data\"",
"]",
"=",
"params",
"return",
"getattr",
"(",
"self",
".",
"session",
",",
"method",
")",
"(",
"*",
"*",
"kwargs",
")"
] |
Creates a response object with the given params and option
Parameters
----------
url : string
The full URL to request.
params: dict
A list of parameters to send with the request. This
will be sent as data for methods that accept a request
body and will otherwise be sent as query parameters.
method : str
The HTTP method to use.
stream : bool
Whether to stream the response.
Returns a requests.Response object.
|
[
"Creates",
"a",
"response",
"object",
"with",
"the",
"given",
"params",
"and",
"option"
] |
train
|
https://github.com/toloco/pyoanda/blob/26b3f28a89d07c5c20d2a645884505387f1daae8/pyoanda/client.py#L54-L91
|
toloco/pyoanda
|
pyoanda/client.py
|
Client.__call
|
def __call(self, uri, params=None, method="get"):
"""Only returns the response, nor the status_code
"""
try:
resp = self.__get_response(uri, params, method, False)
rjson = resp.json(**self.json_options)
assert resp.ok
except AssertionError:
msg = "OCode-{}: {}".format(resp.status_code, rjson["message"])
raise BadRequest(msg)
except Exception as e:
msg = "Bad response: {}".format(e)
log.error(msg, exc_info=True)
raise BadRequest(msg)
else:
return rjson
|
python
|
def __call(self, uri, params=None, method="get"):
"""Only returns the response, nor the status_code
"""
try:
resp = self.__get_response(uri, params, method, False)
rjson = resp.json(**self.json_options)
assert resp.ok
except AssertionError:
msg = "OCode-{}: {}".format(resp.status_code, rjson["message"])
raise BadRequest(msg)
except Exception as e:
msg = "Bad response: {}".format(e)
log.error(msg, exc_info=True)
raise BadRequest(msg)
else:
return rjson
|
[
"def",
"__call",
"(",
"self",
",",
"uri",
",",
"params",
"=",
"None",
",",
"method",
"=",
"\"get\"",
")",
":",
"try",
":",
"resp",
"=",
"self",
".",
"__get_response",
"(",
"uri",
",",
"params",
",",
"method",
",",
"False",
")",
"rjson",
"=",
"resp",
".",
"json",
"(",
"*",
"*",
"self",
".",
"json_options",
")",
"assert",
"resp",
".",
"ok",
"except",
"AssertionError",
":",
"msg",
"=",
"\"OCode-{}: {}\"",
".",
"format",
"(",
"resp",
".",
"status_code",
",",
"rjson",
"[",
"\"message\"",
"]",
")",
"raise",
"BadRequest",
"(",
"msg",
")",
"except",
"Exception",
"as",
"e",
":",
"msg",
"=",
"\"Bad response: {}\"",
".",
"format",
"(",
"e",
")",
"log",
".",
"error",
"(",
"msg",
",",
"exc_info",
"=",
"True",
")",
"raise",
"BadRequest",
"(",
"msg",
")",
"else",
":",
"return",
"rjson"
] |
Only returns the response, nor the status_code
|
[
"Only",
"returns",
"the",
"response",
"nor",
"the",
"status_code"
] |
train
|
https://github.com/toloco/pyoanda/blob/26b3f28a89d07c5c20d2a645884505387f1daae8/pyoanda/client.py#L93-L108
|
toloco/pyoanda
|
pyoanda/client.py
|
Client.__call_stream
|
def __call_stream(self, uri, params=None, method="get"):
"""Returns an stream response
"""
try:
resp = self.__get_response(uri, params, method, True)
assert resp.ok
except AssertionError:
raise BadRequest(resp.status_code)
except Exception as e:
log.error("Bad response: {}".format(e), exc_info=True)
else:
return resp
|
python
|
def __call_stream(self, uri, params=None, method="get"):
"""Returns an stream response
"""
try:
resp = self.__get_response(uri, params, method, True)
assert resp.ok
except AssertionError:
raise BadRequest(resp.status_code)
except Exception as e:
log.error("Bad response: {}".format(e), exc_info=True)
else:
return resp
|
[
"def",
"__call_stream",
"(",
"self",
",",
"uri",
",",
"params",
"=",
"None",
",",
"method",
"=",
"\"get\"",
")",
":",
"try",
":",
"resp",
"=",
"self",
".",
"__get_response",
"(",
"uri",
",",
"params",
",",
"method",
",",
"True",
")",
"assert",
"resp",
".",
"ok",
"except",
"AssertionError",
":",
"raise",
"BadRequest",
"(",
"resp",
".",
"status_code",
")",
"except",
"Exception",
"as",
"e",
":",
"log",
".",
"error",
"(",
"\"Bad response: {}\"",
".",
"format",
"(",
"e",
")",
",",
"exc_info",
"=",
"True",
")",
"else",
":",
"return",
"resp"
] |
Returns an stream response
|
[
"Returns",
"an",
"stream",
"response"
] |
train
|
https://github.com/toloco/pyoanda/blob/26b3f28a89d07c5c20d2a645884505387f1daae8/pyoanda/client.py#L110-L121
|
toloco/pyoanda
|
pyoanda/client.py
|
Client.get_instruments
|
def get_instruments(self):
"""
See more:
http://developer.oanda.com/rest-live/rates/#getInstrumentList
"""
url = "{0}/{1}/instruments".format(self.domain, self.API_VERSION)
params = {"accountId": self.account_id}
try:
response = self._Client__call(uri=url, params=params)
assert len(response) > 0
return response
except RequestException:
return False
except AssertionError:
return False
|
python
|
def get_instruments(self):
"""
See more:
http://developer.oanda.com/rest-live/rates/#getInstrumentList
"""
url = "{0}/{1}/instruments".format(self.domain, self.API_VERSION)
params = {"accountId": self.account_id}
try:
response = self._Client__call(uri=url, params=params)
assert len(response) > 0
return response
except RequestException:
return False
except AssertionError:
return False
|
[
"def",
"get_instruments",
"(",
"self",
")",
":",
"url",
"=",
"\"{0}/{1}/instruments\"",
".",
"format",
"(",
"self",
".",
"domain",
",",
"self",
".",
"API_VERSION",
")",
"params",
"=",
"{",
"\"accountId\"",
":",
"self",
".",
"account_id",
"}",
"try",
":",
"response",
"=",
"self",
".",
"_Client__call",
"(",
"uri",
"=",
"url",
",",
"params",
"=",
"params",
")",
"assert",
"len",
"(",
"response",
")",
">",
"0",
"return",
"response",
"except",
"RequestException",
":",
"return",
"False",
"except",
"AssertionError",
":",
"return",
"False"
] |
See more:
http://developer.oanda.com/rest-live/rates/#getInstrumentList
|
[
"See",
"more",
":",
"http",
":",
"//",
"developer",
".",
"oanda",
".",
"com",
"/",
"rest",
"-",
"live",
"/",
"rates",
"/",
"#getInstrumentList"
] |
train
|
https://github.com/toloco/pyoanda/blob/26b3f28a89d07c5c20d2a645884505387f1daae8/pyoanda/client.py#L123-L137
|
toloco/pyoanda
|
pyoanda/client.py
|
Client.get_prices
|
def get_prices(self, instruments, stream=True):
"""
See more:
http://developer.oanda.com/rest-live/rates/#getCurrentPrices
"""
url = "{0}/{1}/prices".format(
self.domain_stream if stream else self.domain,
self.API_VERSION
)
params = {"accountId": self.account_id, "instruments": instruments}
call = {"uri": url, "params": params, "method": "get"}
try:
if stream:
return self._Client__call_stream(**call)
else:
return self._Client__call(**call)
except RequestException:
return False
except AssertionError:
return False
|
python
|
def get_prices(self, instruments, stream=True):
"""
See more:
http://developer.oanda.com/rest-live/rates/#getCurrentPrices
"""
url = "{0}/{1}/prices".format(
self.domain_stream if stream else self.domain,
self.API_VERSION
)
params = {"accountId": self.account_id, "instruments": instruments}
call = {"uri": url, "params": params, "method": "get"}
try:
if stream:
return self._Client__call_stream(**call)
else:
return self._Client__call(**call)
except RequestException:
return False
except AssertionError:
return False
|
[
"def",
"get_prices",
"(",
"self",
",",
"instruments",
",",
"stream",
"=",
"True",
")",
":",
"url",
"=",
"\"{0}/{1}/prices\"",
".",
"format",
"(",
"self",
".",
"domain_stream",
"if",
"stream",
"else",
"self",
".",
"domain",
",",
"self",
".",
"API_VERSION",
")",
"params",
"=",
"{",
"\"accountId\"",
":",
"self",
".",
"account_id",
",",
"\"instruments\"",
":",
"instruments",
"}",
"call",
"=",
"{",
"\"uri\"",
":",
"url",
",",
"\"params\"",
":",
"params",
",",
"\"method\"",
":",
"\"get\"",
"}",
"try",
":",
"if",
"stream",
":",
"return",
"self",
".",
"_Client__call_stream",
"(",
"*",
"*",
"call",
")",
"else",
":",
"return",
"self",
".",
"_Client__call",
"(",
"*",
"*",
"call",
")",
"except",
"RequestException",
":",
"return",
"False",
"except",
"AssertionError",
":",
"return",
"False"
] |
See more:
http://developer.oanda.com/rest-live/rates/#getCurrentPrices
|
[
"See",
"more",
":",
"http",
":",
"//",
"developer",
".",
"oanda",
".",
"com",
"/",
"rest",
"-",
"live",
"/",
"rates",
"/",
"#getCurrentPrices"
] |
train
|
https://github.com/toloco/pyoanda/blob/26b3f28a89d07c5c20d2a645884505387f1daae8/pyoanda/client.py#L139-L160
|
toloco/pyoanda
|
pyoanda/client.py
|
Client.get_instrument_history
|
def get_instrument_history(self, instrument, candle_format="bidask",
granularity='S5', count=500,
daily_alignment=None, alignment_timezone=None,
weekly_alignment="Monday", start=None,
end=None):
"""
See more:
http://developer.oanda.com/rest-live/rates/#retrieveInstrumentHistory
"""
url = "{0}/{1}/candles".format(self.domain, self.API_VERSION)
params = {
"accountId": self.account_id,
"instrument": instrument,
"candleFormat": candle_format,
"granularity": granularity,
"count": count,
"dailyAlignment": daily_alignment,
"alignmentTimezone": alignment_timezone,
"weeklyAlignment": weekly_alignment,
"start": start,
"end": end,
}
try:
return self._Client__call(uri=url, params=params, method="get")
except RequestException:
return False
except AssertionError:
return False
|
python
|
def get_instrument_history(self, instrument, candle_format="bidask",
granularity='S5', count=500,
daily_alignment=None, alignment_timezone=None,
weekly_alignment="Monday", start=None,
end=None):
"""
See more:
http://developer.oanda.com/rest-live/rates/#retrieveInstrumentHistory
"""
url = "{0}/{1}/candles".format(self.domain, self.API_VERSION)
params = {
"accountId": self.account_id,
"instrument": instrument,
"candleFormat": candle_format,
"granularity": granularity,
"count": count,
"dailyAlignment": daily_alignment,
"alignmentTimezone": alignment_timezone,
"weeklyAlignment": weekly_alignment,
"start": start,
"end": end,
}
try:
return self._Client__call(uri=url, params=params, method="get")
except RequestException:
return False
except AssertionError:
return False
|
[
"def",
"get_instrument_history",
"(",
"self",
",",
"instrument",
",",
"candle_format",
"=",
"\"bidask\"",
",",
"granularity",
"=",
"'S5'",
",",
"count",
"=",
"500",
",",
"daily_alignment",
"=",
"None",
",",
"alignment_timezone",
"=",
"None",
",",
"weekly_alignment",
"=",
"\"Monday\"",
",",
"start",
"=",
"None",
",",
"end",
"=",
"None",
")",
":",
"url",
"=",
"\"{0}/{1}/candles\"",
".",
"format",
"(",
"self",
".",
"domain",
",",
"self",
".",
"API_VERSION",
")",
"params",
"=",
"{",
"\"accountId\"",
":",
"self",
".",
"account_id",
",",
"\"instrument\"",
":",
"instrument",
",",
"\"candleFormat\"",
":",
"candle_format",
",",
"\"granularity\"",
":",
"granularity",
",",
"\"count\"",
":",
"count",
",",
"\"dailyAlignment\"",
":",
"daily_alignment",
",",
"\"alignmentTimezone\"",
":",
"alignment_timezone",
",",
"\"weeklyAlignment\"",
":",
"weekly_alignment",
",",
"\"start\"",
":",
"start",
",",
"\"end\"",
":",
"end",
",",
"}",
"try",
":",
"return",
"self",
".",
"_Client__call",
"(",
"uri",
"=",
"url",
",",
"params",
"=",
"params",
",",
"method",
"=",
"\"get\"",
")",
"except",
"RequestException",
":",
"return",
"False",
"except",
"AssertionError",
":",
"return",
"False"
] |
See more:
http://developer.oanda.com/rest-live/rates/#retrieveInstrumentHistory
|
[
"See",
"more",
":",
"http",
":",
"//",
"developer",
".",
"oanda",
".",
"com",
"/",
"rest",
"-",
"live",
"/",
"rates",
"/",
"#retrieveInstrumentHistory"
] |
train
|
https://github.com/toloco/pyoanda/blob/26b3f28a89d07c5c20d2a645884505387f1daae8/pyoanda/client.py#L162-L189
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.